🔖 Release version 0.8.0

[skip ci]

.env

@@ -1,6 +1,14 @@
 # Domain
 # This would be set to the production domain with an env var on deployment
+# used by Traefik to transmit traffic and aqcuire TLS certificates
 DOMAIN=localhost
+# To test the local Traefik config
+# DOMAIN=localhost.tiangolo.com
+
+# Used by the backend to generate links in emails to the frontend
+FRONTEND_HOST=http://localhost:5173
+# In staging and production, set this env var to the frontend host, e.g.
+# FRONTEND_HOST=https://dashboard.example.com
 
 # Environment: local, staging, production
 ENVIRONMENT=local
@@ -13,7 +21,6 @@ BACKEND_CORS_ORIGINS="http://localhost,http://localhost:5173,https://localhost,h
 SECRET_KEY=changethis
 FIRST_SUPERUSER=admin@example.com
 FIRST_SUPERUSER_PASSWORD=changethis
-USERS_OPEN_REGISTRATION=False
 
 # Emails
 SMTP_HOST=

.github/DISCUSSION_TEMPLATE/questions.yml

@@ -0,0 +1,118 @@
+labels: [question]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for your interest in this project! 🚀
+
+        Please follow these instructions, fill every question, and do every step. 🙏
+
+        I'm asking this because answering questions and solving problems in GitHub is what consumes most of the time.
+
+        I end up not being able to add new features, fix bugs, review pull requests, etc. as fast as I wish because I have to spend too much time handling questions.
+
+        All that, on top of all the incredible help provided by a bunch of community members, that give a lot of their time to come here and help others.
+
+        That's a lot of work, but if more users came to help others like them just a little bit more, it would be much less effort for them (and you and me 😅).
+
+        By asking questions in a structured way (following this) it will be much easier to help you.
+
+        And there's a high chance that you will find the solution along the way and you won't even have to submit it and wait for an answer. 😎
+
+        As there are too many questions, I'll have to discard and close the incomplete ones. That will allow me (and others) to focus on helping people like you that follow the whole process and help us help you. 🤓
+  - type: checkboxes
+    id: checks
+    attributes:
+      label: First Check
+      description: Please confirm and check all the following options.
+      options:
+        - label: I added a very descriptive title here.
+          required: true
+        - label: I used the GitHub search to find a similar question and didn't find it.
+          required: true
+        - label: I searched in the documentation/README.
+          required: true
+        - label: I already searched in Google "How to do X" and didn't find any information.
+          required: true
+        - label: I already read and followed all the tutorial in the docs/README and didn't find an answer.
+          required: true
+  - type: checkboxes
+    id: help
+    attributes:
+      label: Commit to Help
+      description: |
+        After submitting this, I commit to one of:
+
+          * Read open questions until I find 2 where I can help someone and add a comment to help there.
+          * I already hit the "watch" button in this repository to receive notifications and I commit to help at least 2 people that ask questions in the future.
+
+      options:
+        - label: I commit to help with one of those options 👆
+          required: true
+  - type: textarea
+    id: example
+    attributes:
+      label: Example Code
+      description: |
+        Please add a self-contained, [minimal, reproducible, example](https://stackoverflow.com/help/minimal-reproducible-example) with your use case.
+
+        If I (or someone) can copy it, run it, and see it right away, there's a much higher chance I (or someone) will be able to help you.
+
+      placeholder: |
+        Write your example code here.
+      render: Text
+    validations:
+      required: true
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: |
+        What is the problem, question, or error?
+
+        Write a short description telling me what you are doing, what you expect to happen, and what is currently happening.
+      placeholder: |
+        * Open the browser and call the endpoint `/`.
+        * It returns a JSON with `{"message": "Hello World"}`.
+        * But I expected it to return `{"message": "Hello Morty"}`.
+    validations:
+      required: true
+  - type: dropdown
+    id: os
+    attributes:
+      label: Operating System
+      description: What operating system are you on?
+      multiple: true
+      options:
+        - Linux
+        - Windows
+        - macOS
+        - Other
+    validations:
+      required: true
+  - type: textarea
+    id: os-details
+    attributes:
+      label: Operating System Details
+      description: You can add more details about your operating system here, in particular if you chose "Other".
+    validations:
+      required: true
+  - type: input
+    id: python-version
+    attributes:
+      label: Python Version
+      description: |
+        What Python version are you using?
+
+        You can find the Python version with:
+
+        ```bash
+        python --version
+        ```
+    validations:
+      required: true
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional Context
+      description: Add any additional context information or screenshots you think are useful.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,10 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Security Contact
+    about: Please report security vulnerabilities to security@tiangolo.com
+  - name: Question or Problem
+    about: Ask a question or ask about a problem in GitHub Discussions.
+    url: https://github.com/fastapi/full-stack-fastapi-template/discussions/categories/questions
+  - name: Feature Request
+    about: To suggest an idea or ask about a feature, please start with a question saying what you would like to achieve. There might be a way to do it already.
+    url: https://github.com/fastapi/full-stack-fastapi-template/discussions/categories/questions

.github/ISSUE_TEMPLATE/privileged.yml

@@ -0,0 +1,22 @@
+name: Privileged
+description: You are @tiangolo or he asked you directly to create an issue here. If not, check the other options. 👇
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for your interest in this project! 🚀
+
+        If you are not @tiangolo or he didn't ask you directly to create an issue here, please start the conversation in a [Question in GitHub Discussions](https://github.com/tiangolo/full-stack-fastapi-template/discussions/categories/questions) instead.
+  - type: checkboxes
+    id: privileged
+    attributes:
+      label: Privileged issue
+      description: Confirm that you are allowed to create an issue here.
+      options:
+        - label: I'm @tiangolo or he asked me directly to create an issue here.
+          required: true
+  - type: textarea
+    id: content
+    attributes:
+      label: Issue Content
+      description: Add the content of the issue here.

.github/dependabot.yml

@@ -1,16 +1,16 @@
 version: 2
 updates:
   # GitHub Actions
-  - package-ecosystem: "github-actions"
+  - package-ecosystem: github-actions
-    directory: "/"
+    directory: /
     schedule:
-      interval: "daily"
+      interval: daily
     commit-message:
       prefix: ⬆
   # Python
-  - package-ecosystem: "pip"
+  - package-ecosystem: pip
-    directory: "/"
+    directory: /
     schedule:
-      interval: "daily"
+      interval: daily
     commit-message:
       prefix: ⬆

.github/labeler.yml

@@ -0,0 +1,25 @@
+docs:
+  - all:
+    - changed-files:
+      - any-glob-to-any-file:
+        - '**/*.md'
+      - all-globs-to-all-files:
+        - '!frontend/**'
+        - '!backend/**'
+        - '!.github/**'
+        - '!scripts/**'
+        - '!.gitignore'
+        - '!.pre-commit-config.yaml'
+
+internal:
+  - all:
+    - changed-files:
+      - any-glob-to-any-file:
+        - .github/**
+        - scripts/**
+        - .gitignore
+        - .pre-commit-config.yaml
+      - all-globs-to-all-files:
+        - '!./**/*.md'
+        - '!frontend/**'
+        - '!backend/**'

.github/workflows/add-to-project.yml

@@ -0,0 +1,18 @@
+name: Add to Project
+
+on:
+  pull_request_target:
+  issues:
+    types:
+      - opened
+      - reopened
+
+jobs:
+  add-to-project:
+    name: Add to project
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/add-to-project@v1.0.2
+        with:
+          project-url: https://github.com/orgs/fastapi/projects/2
+          github-token: ${{ secrets.PROJECTS_TOKEN }}

.github/workflows/deploy-production.yml

@@ -7,12 +7,15 @@ on:
 
 jobs:
   deploy:
+    # Do not deploy in the main repository, only in user projects
+    if: github.repository_owner != 'fastapi'
     runs-on:
       - self-hosted
       - production
     env:
       ENVIRONMENT: production
       DOMAIN: ${{ secrets.DOMAIN_PRODUCTION }}
+      STACK_NAME: ${{ secrets.STACK_NAME_PRODUCTION }}
       SECRET_KEY: ${{ secrets.SECRET_KEY }}
       FIRST_SUPERUSER: ${{ secrets.FIRST_SUPERUSER }}
       FIRST_SUPERUSER_PASSWORD: ${{ secrets.FIRST_SUPERUSER_PASSWORD }}
@@ -25,5 +28,5 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-      - run: docker compose -f docker-compose.yml build
+      - run: docker compose -f docker-compose.yml --project-name ${{ secrets.STACK_NAME_PRODUCTION }} build
-      - run: docker compose -f docker-compose.yml up -d
+      - run: docker compose -f docker-compose.yml --project-name ${{ secrets.STACK_NAME_PRODUCTION }} up -d

.github/workflows/deploy-staging.yml

@@ -7,12 +7,15 @@ on:
 
 jobs:
   deploy:
+    # Do not deploy in the main repository, only in user projects
+    if: github.repository_owner != 'fastapi'
     runs-on:
       - self-hosted
       - staging
     env:
       ENVIRONMENT: staging
       DOMAIN: ${{ secrets.DOMAIN_STAGING }}
+      STACK_NAME: ${{ secrets.STACK_NAME_STAGING }}
       SECRET_KEY: ${{ secrets.SECRET_KEY }}
       FIRST_SUPERUSER: ${{ secrets.FIRST_SUPERUSER }}
       FIRST_SUPERUSER_PASSWORD: ${{ secrets.FIRST_SUPERUSER_PASSWORD }}
@@ -25,5 +28,5 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-      - run: docker compose -f docker-compose.yml build
+      - run: docker compose -f docker-compose.yml --project-name ${{ secrets.STACK_NAME_STAGING }} build
-      - run: docker compose -f docker-compose.yml up -d
+      - run: docker compose -f docker-compose.yml --project-name ${{ secrets.STACK_NAME_STAGING }} up -d

.github/workflows/generate-client.yml

@@ -0,0 +1,61 @@
+name: Generate Client
+
+on:
+  pull_request:
+    types:
+    - opened
+    - synchronize
+
+jobs:
+  generate-client:
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+    steps:
+    # For PRs from forks
+    - uses: actions/checkout@v4
+    # For PRs from the same repo
+    - uses: actions/checkout@v4
+      if: ( github.event_name != 'pull_request' || github.secret_source == 'Actions' )
+      with:
+        ref: ${{ github.head_ref }}
+        token: ${{ secrets.FULL_STACK_FASTAPI_TEMPLATE_REPO_TOKEN }}
+    - uses: actions/setup-node@v4
+      with:
+        node-version: lts/*
+    - uses: actions/setup-python@v5
+      with:
+        python-version: "3.10"
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        version: "0.4.15"
+        enable-cache: true
+    - name: Install dependencies
+      run: npm ci
+      working-directory: frontend
+    - run: uv sync
+      working-directory: backend
+    - run: uv run bash scripts/generate-client.sh
+      env:
+        VIRTUAL_ENV: backend/.venv
+        ENVIRONMENT: production
+        SECRET_KEY: just-for-generating-client
+        POSTGRES_PASSWORD: just-for-generating-client
+        FIRST_SUPERUSER_PASSWORD: just-for-generating-client
+    - name: Add changes to git
+      run: |
+        git config --local user.email "github-actions@github.com"
+        git config --local user.name "github-actions"
+        git add frontend/src/client
+    # Same repo PRs
+    - name: Push changes
+      if: ( github.event_name != 'pull_request' || github.secret_source == 'Actions' )
+      run: |
+        git diff --staged --quiet || git commit -m "✨ Autogenerate frontend client"
+        git push
+    # Fork PRs
+    - name: Check changes
+      if: ( github.event_name == 'pull_request' && github.secret_source != 'Actions' )
+      run: |
+        git diff --staged --quiet || (echo "Changes detected in generated client, run scripts/generate-client.sh and commit the changes" && exit 1)

.github/workflows/issue-manager.yml

@@ -2,27 +2,46 @@ name: Issue Manager
 
 on:
   schedule:
-    - cron: "0 0 * * *"
+    - cron: "21 17 * * *"
   issue_comment:
     types:
       - created
-      - edited
   issues:
     types:
       - labeled
+  pull_request_target:
+    types:
+      - labeled
+  workflow_dispatch:
+
+permissions:
+  issues: write
+  pull-requests: write
 
 jobs:
   issue-manager:
+    if: github.repository_owner == 'fastapi'
     runs-on: ubuntu-latest
     steps:
-      - uses: tiangolo/issue-manager@0.5.0
+      - name: Dump GitHub context
+        env:
+          GITHUB_CONTEXT: ${{ toJson(github) }}
+        run: echo "$GITHUB_CONTEXT"
+      - uses: tiangolo/issue-manager@0.5.1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           config: >
             {
               "answered": {
-                "users": ["tiangolo"],
                 "delay": 864000,
-                "message": "Assuming the original issue was solved, it will be automatically closed now. But feel free to add more comments or create new issues."
+                "message": "Assuming the original need was handled, this will be automatically closed now. But feel free to add more comments or create new issues or PRs."
+              },
+              "waiting": {
+                "delay": 2628000,
+                "message": "As this PR has been waiting for the original user for a while but seems to be inactive, it's now going to be closed. But if there's anyone interested, feel free to create a new PR."
+              },
+              "invalid": {
+                "delay": 0,
+                "message": "This was marked as invalid and will be closed now. If this is an error, please provide additional details."
               }
             }

.github/workflows/labeler.yml

@@ -0,0 +1,33 @@
+name: Labels
+on:
+  pull_request_target:
+    types:
+      - opened
+      - synchronize
+      - reopened
+      # For label-checker
+      - labeled
+      - unlabeled
+
+jobs:
+  labeler:
+    permissions:
+      contents: read
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/labeler@v5
+      if: ${{ github.event.action != 'labeled' && github.event.action != 'unlabeled' }}
+    - run: echo "Done adding labels"
+  # Run this after labeler applied labels
+  check-labels:
+    needs:
+      - labeler
+    permissions:
+      pull-requests: read
+    runs-on: ubuntu-latest
+    steps:
+      - uses: docker://agilepathway/pull-request-label-checker:latest
+        with:
+          one_of: breaking,security,feature,bug,refactor,upgrade,docs,lang-all,internal
+          repo_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/latest-changes.yml

@@ -12,13 +12,15 @@ on:
         description: PR number
         required: true
       debug_enabled:
-        description: 'Run the build with tmate debugging enabled (https://github.com/marketplace/actions/debugging-with-tmate)'
+        description: "Run the build with tmate debugging enabled (https://github.com/marketplace/actions/debugging-with-tmate)"
         required: false
-        default: 'false'
+        default: "false"
 
 jobs:
   latest-changes:
     runs-on: ubuntu-latest
+    permissions:
+      pull-requests: read
     steps:
       - name: Dump GitHub context
         env:
@@ -27,13 +29,12 @@ jobs:
       - uses: actions/checkout@v4
         with:
           # To allow latest-changes to commit to the main branch
-          token: ${{ secrets.FULL_STACK_FASTAPI_POSTGRESQL_LATEST_CHANGES }}
+          token: ${{ secrets.LATEST_CHANGES }}
-      - uses: docker://tiangolo/latest-changes:0.3.0
+      - uses: tiangolo/latest-changes@0.3.2
-      # - uses: tiangolo/latest-changes@main
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           latest_changes_file: ./release-notes.md
-          latest_changes_header: '## Latest Changes'
+          latest_changes_header: "## Latest Changes"
-          end_regex: '^## '
+          end_regex: "^## "
           debug_logs: true
-          label_header_prefix: '### '
+          label_header_prefix: "### "

.github/workflows/lint-backend.yml

@@ -0,0 +1,28 @@
+name: Lint Backend
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types:
+      - opened
+      - synchronize
+
+jobs:
+  lint-backend:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          version: "0.4.15"
+          enable-cache: true
+      - run: uv run bash scripts/lint.sh
+        working-directory: backend

.github/workflows/playwright.yml

@@ -0,0 +1,131 @@
+name: Playwright Tests
+
+on:
+  push:
+    branches:
+    - master
+  pull_request:
+    types:
+    - opened
+    - synchronize
+  workflow_dispatch:
+    inputs:
+      debug_enabled:
+        description: 'Run the build with tmate debugging enabled (https://github.com/marketplace/actions/debugging-with-tmate)'
+        required: false
+        default: 'false'
+
+jobs:
+  changes:
+    runs-on: ubuntu-latest
+    # Set job outputs to values from filter step
+    outputs:
+      changed: ${{ steps.filter.outputs.changed }}
+    steps:
+    - uses: actions/checkout@v4
+    # For pull requests it's not necessary to checkout the code but for the main branch it is
+    - uses: dorny/paths-filter@v3
+      id: filter
+      with:
+        filters: |
+          changed:
+            - backend/**
+            - frontend/**
+            - .env
+            - docker-compose*.yml
+            - .github/workflows/playwright.yml
+
+  test-playwright:
+    needs:
+      - changes
+    if: ${{ needs.changes.outputs.changed == 'true' }}
+    timeout-minutes: 60
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        shardIndex: [1, 2, 3, 4]
+        shardTotal: [4]
+      fail-fast: false
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-node@v4
+      with:
+        node-version: lts/*
+    - uses: actions/setup-python@v5
+      with:
+        python-version: '3.10'
+    - name: Setup tmate session
+      uses: mxschmitt/action-tmate@v3
+      if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.debug_enabled == 'true' }}
+      with:
+        limit-access-to-actor: true
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        version: "0.4.15"
+        enable-cache: true
+    - run: uv sync
+      working-directory: backend
+    - run: npm ci
+      working-directory: frontend
+    - run: uv run bash scripts/generate-client.sh
+      env:
+        VIRTUAL_ENV: backend/.venv
+    - run: docker compose build
+    - run: docker compose down -v --remove-orphans
+    - name: Run Playwright tests
+      run: docker compose run --rm playwright npx playwright test --fail-on-flaky-tests --trace=retain-on-failure --shard=${{ matrix.shardIndex }}/${{ matrix.shardTotal }}
+    - run: docker compose down -v --remove-orphans
+    - name: Upload blob report to GitHub Actions Artifacts
+      if: ${{ !cancelled() }}
+      uses: actions/upload-artifact@v4
+      with:
+        name: blob-report-${{ matrix.shardIndex }}
+        path: frontend/blob-report
+        include-hidden-files: true
+        retention-days: 1
+
+  merge-playwright-reports:
+    needs:
+      - test-playwright
+      - changes
+    # Merge reports after playwright-tests, even if some shards have failed
+    if: ${{ !cancelled() && needs.changes.outputs.changed == 'true' }}
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-node@v4
+      with:
+        node-version: 20
+    - name: Install dependencies
+      run: npm ci
+      working-directory: frontend
+    - name: Download blob reports from GitHub Actions Artifacts
+      uses: actions/download-artifact@v4
+      with:
+        path: frontend/all-blob-reports
+        pattern: blob-report-*
+        merge-multiple: true
+    - name: Merge into HTML Report
+      run: npx playwright merge-reports --reporter html ./all-blob-reports
+      working-directory: frontend
+    - name: Upload HTML report
+      uses: actions/upload-artifact@v4
+      with:
+        name: html-report--attempt-${{ github.run_attempt }}
+        path: frontend/playwright-report
+        retention-days: 30
+        include-hidden-files: true
+
+  # https://github.com/marketplace/actions/alls-green#why
+  alls-green-playwright:  # This job does nothing and is only used for the branch protection
+    if: always()
+    needs:
+      - test-playwright
+    runs-on: ubuntu-latest
+    steps:
+      - name: Decide whether the needed jobs succeeded or failed
+        uses: re-actors/alls-green@release/v1
+        with:
+          jobs: ${{ toJSON(needs) }}
+          allowed-skips: test-playwright

.github/workflows/smokeshow.yml

@@ -2,30 +2,30 @@ name: Smokeshow
 
 on:
   workflow_run:
-    workflows: [Test]
+    workflows: [Test Backend]
     types: [completed]
 
-permissions:
-  statuses: write
-
 jobs:
   smokeshow:
     if: ${{ github.event.workflow_run.conclusion == 'success' }}
     runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      statuses: write
 
     steps:
+      - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
         with:
-          python-version: '3.9'
+          python-version: "3.10"
-
       - run: pip install smokeshow
-
+      - uses: actions/download-artifact@v4
-      - uses: dawidd6/action-download-artifact@v3.1.2
         with:
-          workflow: test.yml
+          name: coverage-html
-          commit: ${{ github.event.workflow_run.head_sha }}
+          path: backend/htmlcov
-
+          github-token: ${{ secrets.GITHUB_TOKEN }}
-      - run: smokeshow upload coverage-html
+          run-id: ${{ github.event.workflow_run.id }}
+      - run: smokeshow upload backend/htmlcov
         env:
           SMOKESHOW_GITHUB_STATUS_DESCRIPTION: Coverage {coverage-percentage}
           SMOKESHOW_GITHUB_COVERAGE_THRESHOLD: 90

.github/workflows/test-backend.yml

@@ -0,0 +1,41 @@
+name: Test Backend
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types:
+      - opened
+      - synchronize
+
+jobs:
+  test-backend:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          version: "0.4.15"
+          enable-cache: true
+      - run: docker compose down -v --remove-orphans
+      - run: docker compose up -d db mailcatcher
+      - name: Migrate DB
+        run: uv run bash scripts/prestart.sh
+        working-directory: backend
+      - name: Run tests
+        run: uv run bash scripts/tests-start.sh "Coverage for ${{ github.sha }}"
+        working-directory: backend
+      - run: docker compose down -v --remove-orphans
+      - name: Store coverage files
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-html
+          path: backend/htmlcov
+          include-hidden-files: true

.github/workflows/test-docker-compose.yml

@@ -0,0 +1,26 @@
+name: Test Docker Compose
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types:
+      - opened
+      - synchronize
+
+jobs:
+
+  test-docker-compose:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - run: docker compose build
+      - run: docker compose down -v --remove-orphans
+      - run: docker compose up -d --wait backend frontend adminer
+      - name: Test backend is up
+        run: curl http://localhost:8000/api/v1/utils/health-check
+      - name: Test frontend is up
+        run: curl http://localhost:5173
+      - run: docker compose down -v --remove-orphans

.github/workflows/test.yml

@@ -1,49 +0,0 @@
-name: Test
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    types:
-      - opened
-      - synchronize
-
-jobs:
-
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.10'
-
-      - run: docker compose build
-      - run: docker compose down -v --remove-orphans
-      - run: docker compose up -d
-      - name: Lint
-        run: docker compose exec -T backend bash /app/scripts/lint.sh
-      - name: Run tests
-        run: docker compose exec -T backend bash /app/tests-start.sh "Coverage for ${{ github.sha }}"
-      - run: docker compose down -v --remove-orphans
-      - name: Store coverage files
-        uses: actions/upload-artifact@v4
-        with:
-          name: coverage-html
-          path: backend/htmlcov
-
-  # https://github.com/marketplace/actions/alls-green#why
-  alls-green:  # This job does nothing and is only used for the branch protection
-    if: always()
-    needs:
-      - test
-    runs-on: ubuntu-latest
-    steps:
-      - name: Decide whether the needed jobs succeeded or failed
-        uses: re-actors/alls-green@release/v1
-        with:
-          jobs: ${{ toJSON(needs) }}

.gitignore

@@ -1 +1,6 @@
 .vscode
+node_modules/
+/test-results/
+/playwright-report/
+/blob-report/
+/playwright/.cache/

.pre-commit-config.yaml

@@ -1,23 +1,30 @@
 # See https://pre-commit.com for more information
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
--   repo: https://github.com/pre-commit/pre-commit-hooks
+  - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v4.4.0
     hooks:
-    -   id: check-added-large-files
+      - id: check-added-large-files
-    -   id: check-toml
+      - id: check-toml
-    -   id: check-yaml
+      - id: check-yaml
         args:
-        -   --unsafe
+          - --unsafe
-    -   id: end-of-file-fixer
+      - id: end-of-file-fixer
-    -   id: trailing-whitespace
+        exclude: |
--   repo: https://github.com/charliermarsh/ruff-pre-commit
+            (?x)^(
+                frontend/src/client/.*|
+                backend/app/email-templates/build/.*
+            )$
+      - id: trailing-whitespace
+        exclude: ^frontend/src/client/.*
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
     rev: v0.2.2
     hooks:
-    -   id: ruff
+      - id: ruff
         args:
-        - --fix
+          - --fix
-    -   id: ruff-format
+      - id: ruff-format
+
 ci:
-    autofix_commit_msg: 🎨 [pre-commit.ci] Auto format from pre-commit.com hooks
+  autofix_commit_msg: 🎨 [pre-commit.ci] Auto format from pre-commit.com hooks
-    autoupdate_commit_msg: ⬆ [pre-commit.ci] pre-commit autoupdate
+  autoupdate_commit_msg: ⬆ [pre-commit.ci] pre-commit autoupdate

README.md

@@ -1,11 +1,7 @@
 # Full Stack FastAPI Template
 
-<a href="https://github.com/tiangolo/full-stack-fastapi-template/actions?query=workflow%3ATest" target="_blank"><img src="https://github.com/tiangolo/full-stack-fastapi-template/workflows/Test/badge.svg" alt="Test"></a>
+<a href="https://github.com/fastapi/full-stack-fastapi-template/actions?query=workflow%3ATest" target="_blank"><img src="https://github.com/fastapi/full-stack-fastapi-template/workflows/Test/badge.svg" alt="Test"></a>
-<a href="https://coverage-badge.samuelcolvin.workers.dev/redirect/tiangolo/full-stack-fastapi-template" target="_blank"><img src="https://coverage-badge.samuelcolvin.workers.dev/tiangolo/full-stack-fastapi-template.svg" alt="Coverage"></a>
+<a href="https://coverage-badge.samuelcolvin.workers.dev/redirect/fastapi/full-stack-fastapi-template" target="_blank"><img src="https://coverage-badge.samuelcolvin.workers.dev/fastapi/full-stack-fastapi-template.svg" alt="Coverage"></a>
-
-### Dashboard - Dark Mode
-
-[![API docs](img/dashboard-dark.png)](https://github.com/tiangolo/full-stack-fastapi-postgresql)
 
 ## Technology Stack and Features
 
@@ -17,10 +13,11 @@
     - 💃 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 token authentication.
+- 🔑 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.
@@ -29,36 +26,106 @@
 
 ### Dashboard Login
 
-[![API docs](img/login.png)](https://github.com/tiangolo/full-stack-fastapi-template)
+[![API docs](img/login.png)](https://github.com/fastapi/full-stack-fastapi-template)
 
 ### Dashboard - Admin
 
-[![API docs](img/dashboard.png)](https://github.com/tiangolo/full-stack-fastapi-template)
+[![API docs](img/dashboard.png)](https://github.com/fastapi/full-stack-fastapi-template)
 
 ### Dashboard - Create User
 
-[![API docs](img/dashboard-create.png)](https://github.com/tiangolo/full-stack-fastapi-template)
+[![API docs](img/dashboard-create.png)](https://github.com/fastapi/full-stack-fastapi-template)
 
 ### Dashboard - Items
 
-[![API docs](img/dashboard-items.png)](https://github.com/tiangolo/full-stack-fastapi-template)
+[![API docs](img/dashboard-items.png)](https://github.com/fastapi/full-stack-fastapi-template)
 
 ### Dashboard - User Settings
 
-[![API docs](img/dashboard-user-settings.png)](https://github.com/tiangolo/full-stack-fastapi-template)
+[![API docs](img/dashboard-user-settings.png)](https://github.com/fastapi/full-stack-fastapi-template)
 
-### Interactive API documentation
+### Dashboard - Dark Mode
 
-[![API docs](img/docs.png)](https://github.com/tiangolo/full-stack-fastapi-template)
+[![API docs](img/dashboard-dark.png)](https://github.com/fastapi/full-stack-fastapi-template)
 
+### Interactive API Documentation
 
+[![API docs](img/docs.png)](https://github.com/fastapi/full-stack-fastapi-template)
 
-## How to use it
+## 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
+
+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
+git clone git@github.com:fastapi/full-stack-fastapi-template.git my-full-stack
+```
+
+- Enter into the new directory:
+
+```bash
+cd my-full-stack
+```
+
+- Set the new origin to your new repository, copy it from the GitHub interface, for example:
+
+```bash
+git remote set-url origin git@github.com:octocat/my-full-stack.git
+```
+
+- 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
+```
+
+- Push the code to your new repository:
+
+```bash
+git push -u origin master
+```
+
+### 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.
@@ -69,7 +136,11 @@ Before deploying it, make sure you change at least the values for:
 - `FIRST_SUPERUSER_PASSWORD`
 - `POSTGRES_PASSWORD`
 
-### Generate secret keys
+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`.
 
@@ -81,7 +152,7 @@ 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
+## How To Use It - Alternative With Copier
 
 This repository also supports generating a new project using [Copier](https://copier.readthedocs.io).
 
@@ -103,25 +174,25 @@ pipx install copier
 
 **Note**: If you have `pipx`, installing copier is optional, you could run it directly.
 
-### Generate a Project with Copier
+### 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/tiangolo/full-stack-fastapi-template my-awesome-project --trust
+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/tiangolo/full-stack-fastapi-template my-awesome-project --trust
+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/tiangolo/full-stack-fastapi-template/blob/master/.copier/update_dotenv.py) that updates your `.env` files.
+**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
+### Input Variables
 
 Copier will ask you for some data, you might want to have at hand before generating the project.
 
@@ -130,7 +201,7 @@ 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:
 
 - `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 (no spaces) (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).

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. 🙇

backend/Dockerfile

@@ -1,28 +1,43 @@
-FROM tiangolo/uvicorn-gunicorn-fastapi:python3.10
+FROM python:3.10
+
+ENV PYTHONUNBUFFERED=1
 
 WORKDIR /app/
 
-# Install Poetry
+# Install uv
-RUN curl -sSL https://install.python-poetry.org | POETRY_HOME=/opt/poetry python && \
+# Ref: https://docs.astral.sh/uv/guides/integration/docker/#installing-uv
-    cd /usr/local/bin && \
+COPY --from=ghcr.io/astral-sh/uv:0.5.11 /uv /uvx /bin/
-    ln -s /opt/poetry/bin/poetry && \
-    poetry config virtualenvs.create false
 
-# Copy poetry.lock* in case it doesn't exist in the repo
+# Place executables in the environment at the front of the path
-COPY ./pyproject.toml ./poetry.lock* /app/
+# Ref: https://docs.astral.sh/uv/guides/integration/docker/#using-the-environment
+ENV PATH="/app/.venv/bin:$PATH"
 
-# Allow installing dev dependencies to run tests
+# Compile bytecode
-ARG INSTALL_DEV=false
+# Ref: https://docs.astral.sh/uv/guides/integration/docker/#compiling-bytecode
-RUN bash -c "if [ $INSTALL_DEV == 'true' ] ; then poetry install --no-root ; else poetry install --no-root --only main ; fi"
+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/
+COPY ./scripts /app/scripts
 
-COPY ./alembic.ini /app/
+COPY ./pyproject.toml ./uv.lock ./alembic.ini /app/
-
-COPY ./prestart.sh /app/
-
-COPY ./tests-start.sh /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
+
+CMD ["fastapi", "run", "--workers", "4", "app/main.py"]

backend/README.md

@@ -3,84 +3,50 @@
 ## Requirements
 
 * [Docker](https://www.docker.com/).
-* [Poetry](https://python-poetry.org/) for Python package and environment management.
+* [uv](https://docs.astral.sh/uv/) for Python package and environment management.
 
-## Local Development
+## Docker Compose
 
-* Start the stack with Docker Compose:
+Start the local development environment with Docker Compose following the guide in [../development.md](../development.md).
 
-```bash
+## General Workflow
-docker compose up -d
-```
 
-* Now you can open your browser and interact with these URLs:
+By default, the dependencies are managed with [uv](https://docs.astral.sh/uv/), go there and install it.
-
-Frontend, built with Docker, with routes handled based on the path: http://localhost
-
-Backend, JSON based web API based on OpenAPI: http://localhost/api/
-
-Automatic interactive documentation with Swagger UI (from the OpenAPI backend): http://localhost/docs
-
-Adminer, database web administration: http://localhost:8080
-
-Traefik UI, to see how the routes are being handled by the proxy: http://localhost:8090
-
-**Note**: The first time you start your stack, it might take a minute for it to be ready. While the backend waits for the database to be ready and configures everything. You can check the logs to monitor it.
-
-To check the logs, run:
-
-```bash
-docker compose logs
-```
-
-To check the logs of a specific service, add the name of the service, e.g.:
-
-```bash
-docker compose logs backend
-```
-
-If your Docker is not running in `localhost` (the URLs above wouldn't work) you would need to use the IP or domain where your Docker is running.
-
-## Backend local development, additional details
-
-### General workflow
-
-By default, the dependencies are managed with [Poetry](https://python-poetry.org/), go there and install it.
 
 From `./backend/` you can install all the dependencies with:
 
 ```console
-$ poetry install
+$ uv sync
 ```
 
-Then you can start a shell session with the new environment with:
+Then you can activate the virtual environment with:
 
 ```console
-$ poetry shell
+$ source .venv/bin/activate
 ```
 
-Make sure your editor is using the correct Python virtual environment.
+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
+## 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
+## 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 mounted as a Docker "host volume", mapping 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.
+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 `/start-reload.sh` (included in the base image) instead of the default `/start.sh` (also included in the base image). 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:
+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 up -d
+$ 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.
@@ -88,10 +54,10 @@ There is also a commented out `command` override, you can uncomment it and comme
 To get inside the container with a `bash` session you can start the stack with:
 
 ```console
-$ docker compose up -d
+$ docker compose watch
 ```
 
-and then `exec` inside the running container:
+and then in another terminal, `exec` inside the running container:
 
 ```console
 $ docker compose exec backend bash
@@ -105,16 +71,16 @@ 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 script `/start-reload.sh` to run the debug live reloading server. You can run that script from inside the container with:
+There you can use the `fastapi run --reload` command to run the debug live reloading server.
 
 ```console
-$ bash /start-reload.sh
+$ fastapi run --reload app/main.py
 ```
 
 ...it will look like:
 
 ```console
-root@7f2607af31c3:/app# bash /start-reload.sh
+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.
@@ -123,7 +89,7 @@ Nevertheless, if it doesn't detect a change but a syntax error, it will just sto
 
 ...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
+## Backend tests
 
 To test the backend run:
 
@@ -135,27 +101,27 @@ 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
+### 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 /app/tests-start.sh
+docker compose exec backend bash scripts/tests-start.sh
 ```
 
-That `/app/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.
+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 /app/tests-start.sh -x
+docker compose exec backend bash scripts/tests-start.sh -x
 ```
 
-#### Test Coverage
+### 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
+## 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.
 
@@ -183,16 +149,24 @@ $ alembic revision --autogenerate -m "Add column last_name to User model"
 $ alembic upgrade head
 ```
 
-If you don't want to use migrations at all, uncomment the lines in the file at `./backend/app/db/init_db.py` that end in:
+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 `prestart.sh` that contains:
+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.

backend/app/alembic/env.py

@@ -19,6 +19,7 @@ fileConfig(config.config_file_name)
 # target_metadata = None
 
 from app.models import SQLModel  # noqa
+from app.core.config import settings # noqa
 
 target_metadata = SQLModel.metadata
 
@@ -29,12 +30,7 @@ target_metadata = SQLModel.metadata
 
 
 def get_url():
-    user = os.getenv("POSTGRES_USER", "postgres")
+    return str(settings.SQLALCHEMY_DATABASE_URI)
-    password = os.getenv("POSTGRES_PASSWORD", "")
-    server = os.getenv("POSTGRES_SERVER", "db")
-    port = os.getenv("POSTGRES_PORT", "5432")
-    db = os.getenv("POSTGRES_DB", "app")
-    return f"postgresql+psycopg://{user}:{password}@{server}:{port}/{db}"
 
 
 def run_migrations_offline():

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 ###

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)

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'])

backend/app/api/deps.py

@@ -1,9 +1,10 @@
 from collections.abc import Generator
 from typing import Annotated
 
+import jwt
 from fastapi import Depends, HTTPException, status
 from fastapi.security import OAuth2PasswordBearer
-from jose import JWTError, jwt
+from jwt.exceptions import InvalidTokenError
 from pydantic import ValidationError
 from sqlmodel import Session
 
@@ -32,7 +33,7 @@ def get_current_user(session: SessionDep, token: TokenDep) -> User:
             token, settings.SECRET_KEY, algorithms=[security.ALGORITHM]
         )
         token_data = TokenPayload(**payload)
-    except (JWTError, ValidationError):
+    except (InvalidTokenError, ValidationError):
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
             detail="Could not validate credentials",
@@ -51,6 +52,6 @@ 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=400, detail="The user doesn't have enough privileges"
+            status_code=403, detail="The user doesn't have enough privileges"
         )
     return current_user

backend/app/api/main.py

@@ -1,9 +1,14 @@
 from fastapi import APIRouter
 
-from app.api.routes import items, login, users, utils
+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, tags=["login"])
+api_router.include_router(login.router)
-api_router.include_router(users.router, prefix="/users", tags=["users"])
+api_router.include_router(users.router)
-api_router.include_router(utils.router, prefix="/utils", tags=["utils"])
+api_router.include_router(utils.router)
-api_router.include_router(items.router, prefix="/items", tags=["items"])
+api_router.include_router(items.router)
+
+
+if settings.ENVIRONMENT == "local":
+    api_router.include_router(private.router)

backend/app/api/routes/items.py

@@ -1,15 +1,16 @@
+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, ItemOut, ItemsOut, ItemUpdate, Message
+from app.models import Item, ItemCreate, ItemPublic, ItemsPublic, ItemUpdate, Message
 
-router = APIRouter()
+router = APIRouter(prefix="/items", tags=["items"])
 
 
-@router.get("/", response_model=ItemsOut)
+@router.get("/", response_model=ItemsPublic)
 def read_items(
     session: SessionDep, current_user: CurrentUser, skip: int = 0, limit: int = 100
 ) -> Any:
@@ -18,17 +19,17 @@ def read_items(
     """
 
     if current_user.is_superuser:
-        statment = select(func.count()).select_from(Item)
+        count_statement = select(func.count()).select_from(Item)
-        count = session.exec(statment).one()
+        count = session.exec(count_statement).one()
         statement = select(Item).offset(skip).limit(limit)
         items = session.exec(statement).all()
     else:
-        statment = (
+        count_statement = (
             select(func.count())
             .select_from(Item)
             .where(Item.owner_id == current_user.id)
         )
-        count = session.exec(statment).one()
+        count = session.exec(count_statement).one()
         statement = (
             select(Item)
             .where(Item.owner_id == current_user.id)
@@ -37,11 +38,11 @@ def read_items(
         )
         items = session.exec(statement).all()
 
-    return ItemsOut(data=items, count=count)
+    return ItemsPublic(data=items, count=count)
 
 
-@router.get("/{id}", response_model=ItemOut)
+@router.get("/{id}", response_model=ItemPublic)
-def read_item(session: SessionDep, current_user: CurrentUser, id: int) -> Any:
+def read_item(session: SessionDep, current_user: CurrentUser, id: uuid.UUID) -> Any:
     """
     Get item by ID.
     """
@@ -53,7 +54,7 @@ def read_item(session: SessionDep, current_user: CurrentUser, id: int) -> Any:
     return item
 
 
-@router.post("/", response_model=ItemOut)
+@router.post("/", response_model=ItemPublic)
 def create_item(
     *, session: SessionDep, current_user: CurrentUser, item_in: ItemCreate
 ) -> Any:
@@ -67,9 +68,13 @@ def create_item(
     return item
 
 
-@router.put("/{id}", response_model=ItemOut)
+@router.put("/{id}", response_model=ItemPublic)
 def update_item(
-    *, session: SessionDep, current_user: CurrentUser, id: int, item_in: ItemUpdate
+    *,
+    session: SessionDep,
+    current_user: CurrentUser,
+    id: uuid.UUID,
+    item_in: ItemUpdate,
 ) -> Any:
     """
     Update an item.
@@ -88,7 +93,9 @@ def update_item(
 
 
 @router.delete("/{id}")
-def delete_item(session: SessionDep, current_user: CurrentUser, id: int) -> Message:
+def delete_item(
+    session: SessionDep, current_user: CurrentUser, id: uuid.UUID
+) -> Message:
     """
     Delete an item.
     """

backend/app/api/routes/login.py

@@ -10,7 +10,7 @@ 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, UserOut
+from app.models import Message, NewPassword, Token, UserPublic
 from app.utils import (
     generate_password_reset_token,
     generate_reset_password_email,
@@ -18,7 +18,7 @@ from app.utils import (
     verify_password_reset_token,
 )
 
-router = APIRouter()
+router = APIRouter(tags=["login"])
 
 
 @router.post("/login/access-token")
@@ -43,7 +43,7 @@ def login_access_token(
     )
 
 
-@router.post("/login/test-token", response_model=UserOut)
+@router.post("/login/test-token", response_model=UserPublic)
 def test_token(current_user: CurrentUser) -> Any:
     """
     Test access token

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

backend/app/api/routes/users.py

@@ -1,3 +1,4 @@
+import uuid
 from typing import Any
 
 from fastapi import APIRouter, Depends, HTTPException
@@ -17,36 +18,38 @@ from app.models import (
     UpdatePassword,
     User,
     UserCreate,
-    UserCreateOpen,
+    UserPublic,
-    UserOut,
+    UserRegister,
-    UsersOut,
+    UsersPublic,
     UserUpdate,
     UserUpdateMe,
 )
 from app.utils import generate_new_account_email, send_email
 
-router = APIRouter()
+router = APIRouter(prefix="/users", tags=["users"])
 
 
 @router.get(
-    "/", dependencies=[Depends(get_current_active_superuser)], response_model=UsersOut
+    "/",
+    dependencies=[Depends(get_current_active_superuser)],
+    response_model=UsersPublic,
 )
 def read_users(session: SessionDep, skip: int = 0, limit: int = 100) -> Any:
     """
     Retrieve users.
     """
 
-    statment = select(func.count()).select_from(User)
+    count_statement = select(func.count()).select_from(User)
-    count = session.exec(statment).one()
+    count = session.exec(count_statement).one()
 
     statement = select(User).offset(skip).limit(limit)
     users = session.exec(statement).all()
 
-    return UsersOut(data=users, count=count)
+    return UsersPublic(data=users, count=count)
 
 
 @router.post(
-    "/", dependencies=[Depends(get_current_active_superuser)], response_model=UserOut
+    "/", dependencies=[Depends(get_current_active_superuser)], response_model=UserPublic
 )
 def create_user(*, session: SessionDep, user_in: UserCreate) -> Any:
     """
@@ -72,7 +75,7 @@ def create_user(*, session: SessionDep, user_in: UserCreate) -> Any:
     return user
 
 
-@router.patch("/me", response_model=UserOut)
+@router.patch("/me", response_model=UserPublic)
 def update_user_me(
     *, session: SessionDep, user_in: UserUpdateMe, current_user: CurrentUser
 ) -> Any:
@@ -114,38 +117,47 @@ def update_password_me(
     return Message(message="Password updated successfully")
 
 
-@router.get("/me", response_model=UserOut)
+@router.get("/me", response_model=UserPublic)
-def read_user_me(session: SessionDep, current_user: CurrentUser) -> Any:
+def read_user_me(current_user: CurrentUser) -> Any:
     """
     Get current user.
     """
     return current_user
 
 
-@router.post("/open", response_model=UserOut)
+@router.delete("/me", response_model=Message)
-def create_user_open(session: SessionDep, user_in: UserCreateOpen) -> Any:
+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.
     """
-    if not settings.USERS_OPEN_REGISTRATION:
-        raise HTTPException(
-            status_code=403,
-            detail="Open user registration is forbidden on this server",
-        )
     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.from_orm(user_in)
+    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=UserOut)
+@router.get("/{user_id}", response_model=UserPublic)
 def read_user_by_id(
-    user_id: int, session: SessionDep, current_user: CurrentUser
+    user_id: uuid.UUID, session: SessionDep, current_user: CurrentUser
 ) -> Any:
     """
     Get a specific user by id.
@@ -164,12 +176,12 @@ def read_user_by_id(
 @router.patch(
     "/{user_id}",
     dependencies=[Depends(get_current_active_superuser)],
-    response_model=UserOut,
+    response_model=UserPublic,
 )
 def update_user(
     *,
     session: SessionDep,
-    user_id: int,
+    user_id: uuid.UUID,
     user_in: UserUpdate,
 ) -> Any:
     """
@@ -193,9 +205,9 @@ def update_user(
     return db_user
 
 
-@router.delete("/{user_id}")
+@router.delete("/{user_id}", dependencies=[Depends(get_current_active_superuser)])
 def delete_user(
-    session: SessionDep, current_user: CurrentUser, user_id: int
+    session: SessionDep, current_user: CurrentUser, user_id: uuid.UUID
 ) -> Message:
     """
     Delete a user.
@@ -203,15 +215,10 @@ def delete_user(
     user = session.get(User, user_id)
     if not user:
         raise HTTPException(status_code=404, detail="User not found")
-    elif user != current_user and not current_user.is_superuser:
+    if user == current_user:
-        raise HTTPException(
-            status_code=403, detail="The user doesn't have enough privileges"
-        )
-    elif user == current_user and 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) == user_id)
     session.exec(statement)  # type: ignore
     session.delete(user)

backend/app/api/routes/utils.py

@@ -5,7 +5,7 @@ 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()
+router = APIRouter(prefix="/utils", tags=["utils"])
 
 
 @router.post(
@@ -24,3 +24,8 @@ def test_email(email_to: EmailStr) -> Message:
         html_content=email_data.html_content,
     )
     return Message(message="Test email sent")
+
+
+@router.get("/health-check/")
+async def health_check() -> bool:
+    return True

backend/app/celeryworker_pre_start.py

@@ -1,39 +0,0 @@
-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.core.db import engine
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-max_tries = 60 * 5  # 5 minutes
-wait_seconds = 1
-
-
-@retry(
-    stop=stop_after_attempt(max_tries),
-    wait=wait_fixed(wait_seconds),
-    before=before_log(logger, logging.INFO),
-    after=after_log(logger, logging.WARN),
-)
-def init(db_engine: Engine) -> None:
-    try:
-        # Try to create session to check if DB is awake
-        with Session(db_engine) as session:
-            session.exec(select(1))
-    except Exception as e:
-        logger.error(e)
-        raise e
-
-
-def main() -> None:
-    logger.info("Initializing service")
-    init(engine)
-    logger.info("Service finished initializing")
-
-
-if __name__ == "__main__":
-    main()

backend/app/core/config.py

@@ -5,6 +5,7 @@ from typing import Annotated, Any, Literal
 from pydantic import (
     AnyUrl,
     BeforeValidator,
+    EmailStr,
     HttpUrl,
     PostgresDsn,
     computed_field,
@@ -25,36 +26,38 @@ def parse_cors(v: Any) -> list[str] | str:
 
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(
-        env_file=".env", env_ignore_empty=True, extra="ignore"
+        # 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
-    DOMAIN: str = "localhost"
+    FRONTEND_HOST: str = "http://localhost:5173"
     ENVIRONMENT: Literal["local", "staging", "production"] = "local"
 
-    @computed_field  # type: ignore[misc]
-    @property
-    def server_host(self) -> str:
-        # Use HTTPS for anything other than local development
-        if self.ENVIRONMENT == "local":
-            return f"http://{self.DOMAIN}"
-        return f"https://{self.DOMAIN}"
-
     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_PASSWORD: str = ""
     POSTGRES_DB: str = ""
 
-    @computed_field  # type: ignore[misc]
+    @computed_field  # type: ignore[prop-decorator]
     @property
     def SQLALCHEMY_DATABASE_URI(self) -> PostgresDsn:
         return MultiHostUrl.build(
@@ -72,9 +75,8 @@ class Settings(BaseSettings):
     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: EmailStr | None = None
-    EMAILS_FROM_EMAIL: str | None = None
+    EMAILS_FROM_NAME: EmailStr | None = None
-    EMAILS_FROM_NAME: str | None = None
 
     @model_validator(mode="after")
     def _set_default_emails_from(self) -> Self:
@@ -84,17 +86,14 @@ class Settings(BaseSettings):
 
     EMAIL_RESET_TOKEN_EXPIRE_HOURS: int = 48
 
-    @computed_field  # type: ignore[misc]
+    @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: EmailStr = "test@example.com"
-    EMAIL_TEST_USER: str = "test@example.com"
+    FIRST_SUPERUSER: EmailStr
-    # TODO: update type to EmailStr when sqlmodel supports it
-    FIRST_SUPERUSER: str
     FIRST_SUPERUSER_PASSWORD: str
-    USERS_OPEN_REGISTRATION: bool = False
 
     def _check_default_secret(self, var_name: str, value: str | None) -> None:
         if value == "changethis":

backend/app/core/db.py

@@ -9,7 +9,7 @@ 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/tiangolo/full-stack-fastapi-template/issues/28
+# for more details: https://github.com/fastapi/full-stack-fastapi-template/issues/28
 
 
 def init_db(session: Session) -> None:
@@ -18,7 +18,6 @@ def init_db(session: Session) -> None:
     # the tables un-commenting the next lines
     # from sqlmodel import SQLModel
 
-    # from app.core.engine import engine
     # This works because the models are already imported and registered from app.models
     # SQLModel.metadata.create_all(engine)
 

backend/app/core/security.py

@@ -1,7 +1,7 @@
-from datetime import datetime, timedelta
+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
@@ -13,7 +13,7 @@ ALGORITHM = "HS256"
 
 
 def create_access_token(subject: str | Any, expires_delta: timedelta) -> str:
-    expire = datetime.utcnow() + expires_delta
+    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

backend/app/crud.py

@@ -1,3 +1,4 @@
+import uuid
 from typing import Any
 
 from sqlmodel import Session, select
@@ -45,7 +46,7 @@ def authenticate(*, session: Session, email: str, password: str) -> User | None:
     return db_user
 
 
-def create_item(*, session: Session, item_in: ItemCreate, owner_id: int) -> Item:
+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()

backend/app/main.py

@@ -1,3 +1,4 @@
+import sentry_sdk
 from fastapi import FastAPI
 from fastapi.routing import APIRoute
 from starlette.middleware.cors import CORSMiddleware
@@ -10,6 +11,9 @@ def custom_generate_unique_id(route: APIRoute) -> str:
     return f"{route.tags[0]}-{route.name}"
 
 
+if settings.SENTRY_DSN and settings.ENVIRONMENT != "local":
+    sentry_sdk.init(dsn=str(settings.SENTRY_DSN), enable_tracing=True)
+
 app = FastAPI(
     title=settings.PROJECT_NAME,
     openapi_url=f"{settings.API_V1_STR}/openapi.json",
@@ -17,12 +21,10 @@ app = FastAPI(
 )
 
 # Set all CORS enabled origins
-if settings.BACKEND_CORS_ORIGINS:
+if settings.all_cors_origins:
     app.add_middleware(
         CORSMiddleware,
-        allow_origins=[
+        allow_origins=settings.all_cors_origins,
-            str(origin).strip("/") for origin in settings.BACKEND_CORS_ORIGINS
-        ],
         allow_credentials=True,
         allow_methods=["*"],
         allow_headers=["*"],

backend/app/models.py

@@ -1,94 +1,95 @@
+import uuid
+
+from pydantic import EmailStr
 from sqlmodel import Field, Relationship, SQLModel
 
 
 # Shared properties
-# TODO replace email str with EmailStr when sqlmodel supports it
 class UserBase(SQLModel):
-    email: str = Field(unique=True, index=True)
+    email: EmailStr = Field(unique=True, index=True, max_length=255)
     is_active: bool = True
     is_superuser: bool = False
-    full_name: str | None = None
+    full_name: str | None = Field(default=None, max_length=255)
 
 
 # Properties to receive via API on creation
 class UserCreate(UserBase):
-    password: str
+    password: str = Field(min_length=8, max_length=40)
 
 
-# TODO replace email str with EmailStr when sqlmodel supports it
+class UserRegister(SQLModel):
-class UserCreateOpen(SQLModel):
+    email: EmailStr = Field(max_length=255)
-    email: str
+    password: str = Field(min_length=8, max_length=40)
-    password: str
+    full_name: str | None = Field(default=None, max_length=255)
-    full_name: str | None = None
 
 
 # Properties to receive via API on update, all are optional
-# TODO replace email str with EmailStr when sqlmodel supports it
 class UserUpdate(UserBase):
-    email: str | None = None  # type: ignore
+    email: EmailStr | None = Field(default=None, max_length=255)  # type: ignore
-    password: str | None = None
+    password: str | None = Field(default=None, min_length=8, max_length=40)
 
 
-# TODO replace email str with EmailStr when sqlmodel supports it
 class UserUpdateMe(SQLModel):
-    full_name: str | None = None
+    full_name: str | None = Field(default=None, max_length=255)
-    email: str | None = None
+    email: EmailStr | None = Field(default=None, max_length=255)
 
 
 class UpdatePassword(SQLModel):
-    current_password: str
+    current_password: str = Field(min_length=8, max_length=40)
-    new_password: str
+    new_password: str = Field(min_length=8, max_length=40)
 
 
 # Database model, database table inferred from class name
 class User(UserBase, table=True):
-    id: int | None = Field(default=None, primary_key=True)
+    id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
     hashed_password: str
-    items: list["Item"] = Relationship(back_populates="owner")
+    items: list["Item"] = Relationship(back_populates="owner", cascade_delete=True)
 
 
 # Properties to return via API, id is always required
-class UserOut(UserBase):
+class UserPublic(UserBase):
-    id: int
+    id: uuid.UUID
 
 
-class UsersOut(SQLModel):
+class UsersPublic(SQLModel):
-    data: list[UserOut]
+    data: list[UserPublic]
     count: int
 
 
 # Shared properties
 class ItemBase(SQLModel):
-    title: str
+    title: str = Field(min_length=1, max_length=255)
-    description: str | None = None
+    description: str | None = Field(default=None, max_length=255)
 
 
 # Properties to receive on item creation
 class ItemCreate(ItemBase):
-    title: str
+    pass
 
 
 # Properties to receive on item update
 class ItemUpdate(ItemBase):
-    title: str | None = None  # type: ignore
+    title: str | None = Field(default=None, min_length=1, max_length=255)  # type: ignore
 
 
 # Database model, database table inferred from class name
 class Item(ItemBase, table=True):
-    id: int | None = Field(default=None, primary_key=True)
+    id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
-    title: str
+    title: str = Field(max_length=255)
-    owner_id: int | None = Field(default=None, foreign_key="user.id", nullable=False)
+    owner_id: uuid.UUID = Field(
+        foreign_key="user.id", nullable=False, ondelete="CASCADE"
+    )
     owner: User | None = Relationship(back_populates="items")
 
 
 # Properties to return via API, id is always required
-class ItemOut(ItemBase):
+class ItemPublic(ItemBase):
-    id: int
+    id: uuid.UUID
-    owner_id: int
+    owner_id: uuid.UUID
 
 
-class ItemsOut(SQLModel):
+class ItemsPublic(SQLModel):
-    data: list[ItemOut]
+    data: list[ItemPublic]
     count: int
 
 
@@ -105,9 +106,9 @@ class Token(SQLModel):
 
 # Contents of JWT token
 class TokenPayload(SQLModel):
-    sub: int | None = None
+    sub: str | None = None
 
 
 class NewPassword(SQLModel):
     token: str
-    new_password: str
+    new_password: str = Field(min_length=8, max_length=40)

backend/app/tests/api/routes/test_items.py

@@ -1,3 +1,5 @@
+import uuid
+
 from fastapi.testclient import TestClient
 from sqlmodel import Session
 
@@ -6,7 +8,7 @@ from app.tests.utils.item import create_random_item
 
 
 def test_create_item(
-    client: TestClient, superuser_token_headers: dict[str, str], db: Session
+    client: TestClient, superuser_token_headers: dict[str, str]
 ) -> None:
     data = {"title": "Foo", "description": "Fighters"}
     response = client.post(
@@ -34,15 +36,15 @@ def test_read_item(
     content = response.json()
     assert content["title"] == item.title
     assert content["description"] == item.description
-    assert content["id"] == item.id
+    assert content["id"] == str(item.id)
-    assert content["owner_id"] == item.owner_id
+    assert content["owner_id"] == str(item.owner_id)
 
 
 def test_read_item_not_found(
-    client: TestClient, superuser_token_headers: dict[str, str], db: Session
+    client: TestClient, superuser_token_headers: dict[str, str]
 ) -> None:
     response = client.get(
-        f"{settings.API_V1_STR}/items/999",
+        f"{settings.API_V1_STR}/items/{uuid.uuid4()}",
         headers=superuser_token_headers,
     )
     assert response.status_code == 404
@@ -91,16 +93,16 @@ def test_update_item(
     content = response.json()
     assert content["title"] == data["title"]
     assert content["description"] == data["description"]
-    assert content["id"] == item.id
+    assert content["id"] == str(item.id)
-    assert content["owner_id"] == item.owner_id
+    assert content["owner_id"] == str(item.owner_id)
 
 
 def test_update_item_not_found(
-    client: TestClient, superuser_token_headers: dict[str, str], db: Session
+    client: TestClient, superuser_token_headers: dict[str, str]
 ) -> None:
     data = {"title": "Updated title", "description": "Updated description"}
     response = client.put(
-        f"{settings.API_V1_STR}/items/999",
+        f"{settings.API_V1_STR}/items/{uuid.uuid4()}",
         headers=superuser_token_headers,
         json=data,
     )
@@ -138,10 +140,10 @@ def test_delete_item(
 
 
 def test_delete_item_not_found(
-    client: TestClient, superuser_token_headers: dict[str, str], db: Session
+    client: TestClient, superuser_token_headers: dict[str, str]
 ) -> None:
     response = client.delete(
-        f"{settings.API_V1_STR}/items/999",
+        f"{settings.API_V1_STR}/items/{uuid.uuid4()}",
         headers=superuser_token_headers,
     )
     assert response.status_code == 404

backend/app/tests/api/routes/test_login.py

@@ -1,7 +1,14 @@
+from unittest.mock import patch
+
 from fastapi.testclient import TestClient
-from pytest_mock import MockerFixture
+from sqlmodel import Session
 
 from app.core.config import settings
+from app.core.security import verify_password
+from app.crud import create_user
+from app.models import UserCreate
+from app.tests.utils.user import user_authentication_headers
+from app.tests.utils.utils import random_email, random_lower_string
 from app.utils import generate_password_reset_token
 
 
@@ -39,18 +46,19 @@ def test_use_access_token(
 
 
 def test_recovery_password(
-    client: TestClient, normal_user_token_headers: dict[str, str], mocker: MockerFixture
+    client: TestClient, normal_user_token_headers: dict[str, str]
 ) -> None:
-    mocker.patch("app.utils.send_email", return_value=None)
+    with (
-    mocker.patch("app.core.config.settings.SMTP_HOST", "smtp.example.com")
+        patch("app.core.config.settings.SMTP_HOST", "smtp.example.com"),
-    mocker.patch("app.core.config.settings.SMTP_USER", "admin@example.com")
+        patch("app.core.config.settings.SMTP_USER", "admin@example.com"),
-    email = "test@example.com"
+    ):
-    r = client.post(
+        email = "test@example.com"
-        f"{settings.API_V1_STR}/password-recovery/{email}",
+        r = client.post(
-        headers=normal_user_token_headers,
+            f"{settings.API_V1_STR}/password-recovery/{email}",
-    )
+            headers=normal_user_token_headers,
-    assert r.status_code == 200
+        )
-    assert r.json() == {"message": "Password recovery email sent"}
+        assert r.status_code == 200
+        assert r.json() == {"message": "Password recovery email sent"}
 
 
 def test_recovery_password_user_not_exits(
@@ -64,19 +72,35 @@ def test_recovery_password_user_not_exits(
     assert r.status_code == 404
 
 
-def test_reset_password(
+def test_reset_password(client: TestClient, db: Session) -> None:
-    client: TestClient, superuser_token_headers: dict[str, str]
+    email = random_email()
-) -> None:
+    password = random_lower_string()
-    token = generate_password_reset_token(email=settings.FIRST_SUPERUSER)
+    new_password = random_lower_string()
-    data = {"new_password": "changethis", "token": token}
+
+    user_create = UserCreate(
+        email=email,
+        full_name="Test User",
+        password=password,
+        is_active=True,
+        is_superuser=False,
+    )
+    user = create_user(session=db, user_create=user_create)
+    token = generate_password_reset_token(email=email)
+    headers = user_authentication_headers(client=client, email=email, password=password)
+    data = {"new_password": new_password, "token": token}
+
     r = client.post(
         f"{settings.API_V1_STR}/reset-password/",
-        headers=superuser_token_headers,
+        headers=headers,
         json=data,
     )
+
     assert r.status_code == 200
     assert r.json() == {"message": "Password updated successfully"}
 
+    db.refresh(user)
+    assert verify_password(new_password, user.hashed_password)
+
 
 def test_reset_password_invalid_token(
     client: TestClient, superuser_token_headers: dict[str, str]

backend/app/tests/api/routes/test_private.py

@@ -0,0 +1,26 @@
+from fastapi.testclient import TestClient
+from sqlmodel import Session, select
+
+from app.core.config import settings
+from app.models import User
+
+
+def test_create_user(client: TestClient, db: Session) -> None:
+    r = client.post(
+        f"{settings.API_V1_STR}/private/users/",
+        json={
+            "email": "pollo@listo.com",
+            "password": "password123",
+            "full_name": "Pollo Listo",
+        },
+    )
+
+    assert r.status_code == 200
+
+    data = r.json()
+
+    user = db.exec(select(User).where(User.id == data["id"])).first()
+
+    assert user
+    assert user.email == "pollo@listo.com"
+    assert user.full_name == "Pollo Listo"

backend/app/tests/api/routes/test_users.py

@@ -1,10 +1,13 @@
+import uuid
+from unittest.mock import patch
+
 from fastapi.testclient import TestClient
-from pytest_mock import MockerFixture
+from sqlmodel import Session, select
-from sqlmodel import Session
 
 from app import crud
 from app.core.config import settings
-from app.models import UserCreate
+from app.core.security import verify_password
+from app.models import User, UserCreate
 from app.tests.utils.utils import random_email, random_lower_string
 
 
@@ -31,27 +34,26 @@ def test_get_users_normal_user_me(
 
 
 def test_create_user_new_email(
-    client: TestClient,
+    client: TestClient, superuser_token_headers: dict[str, str], db: Session
-    superuser_token_headers: dict[str, str],
-    db: Session,
-    mocker: MockerFixture,
 ) -> None:
-    mocker.patch("app.utils.send_email")
+    with (
-    mocker.patch("app.core.config.settings.SMTP_HOST", "smtp.example.com")
+        patch("app.utils.send_email", return_value=None),
-    mocker.patch("app.core.config.settings.SMTP_USER", "admin@example.com")
+        patch("app.core.config.settings.SMTP_HOST", "smtp.example.com"),
-    username = random_email()
+        patch("app.core.config.settings.SMTP_USER", "admin@example.com"),
-    password = random_lower_string()
+    ):
-    data = {"email": username, "password": password}
+        username = random_email()
-    r = client.post(
+        password = random_lower_string()
-        f"{settings.API_V1_STR}/users/",
+        data = {"email": username, "password": password}
-        headers=superuser_token_headers,
+        r = client.post(
-        json=data,
+            f"{settings.API_V1_STR}/users/",
-    )
+            headers=superuser_token_headers,
-    assert 200 <= r.status_code < 300
+            json=data,
-    created_user = r.json()
+        )
-    user = crud.get_user_by_email(session=db, email=username)
+        assert 200 <= r.status_code < 300
-    assert user
+        created_user = r.json()
-    assert user.email == created_user["email"]
+        user = crud.get_user_by_email(session=db, email=username)
+        assert user
+        assert user.email == created_user["email"]
 
 
 def test_get_existing_user(
@@ -101,10 +103,10 @@ def test_get_existing_user_current_user(client: TestClient, db: Session) -> None
 
 
 def test_get_existing_user_permissions_error(
-    client: TestClient, normal_user_token_headers: dict[str, str], db: Session
+    client: TestClient, normal_user_token_headers: dict[str, str]
 ) -> None:
     r = client.get(
-        f"{settings.API_V1_STR}/users/999999",
+        f"{settings.API_V1_STR}/users/{uuid.uuid4()}",
         headers=normal_user_token_headers,
     )
     assert r.status_code == 403
@@ -141,7 +143,7 @@ def test_create_user_by_normal_user(
         headers=normal_user_token_headers,
         json=data,
     )
-    assert r.status_code == 400
+    assert r.status_code == 403
 
 
 def test_retrieve_users(
@@ -182,6 +184,12 @@ def test_update_user_me(
     assert updated_user["email"] == email
     assert updated_user["full_name"] == full_name
 
+    user_query = select(User).where(User.email == email)
+    user_db = db.exec(user_query).first()
+    assert user_db
+    assert user_db.email == email
+    assert user_db.full_name == full_name
+
 
 def test_update_password_me(
     client: TestClient, superuser_token_headers: dict[str, str], db: Session
@@ -200,6 +208,12 @@ def test_update_password_me(
     updated_user = r.json()
     assert updated_user["message"] == "Password updated successfully"
 
+    user_query = select(User).where(User.email == settings.FIRST_SUPERUSER)
+    user_db = db.exec(user_query).first()
+    assert user_db
+    assert user_db.email == settings.FIRST_SUPERUSER
+    assert verify_password(new_password, user_db.hashed_password)
+
     # Revert to the old password to keep consistency in test
     old_data = {
         "current_password": new_password,
@@ -210,11 +224,14 @@ def test_update_password_me(
         headers=superuser_token_headers,
         json=old_data,
     )
+    db.refresh(user_db)
+
     assert r.status_code == 200
+    assert verify_password(settings.FIRST_SUPERUSER_PASSWORD, user_db.hashed_password)
 
 
 def test_update_password_me_incorrect_password(
-    client: TestClient, superuser_token_headers: dict[str, str], db: Session
+    client: TestClient, superuser_token_headers: dict[str, str]
 ) -> None:
     new_password = random_lower_string()
     data = {"current_password": new_password, "new_password": new_password}
@@ -247,7 +264,7 @@ def test_update_user_me_email_exists(
 
 
 def test_update_password_me_same_password_error(
-    client: TestClient, superuser_token_headers: dict[str, str], db: Session
+    client: TestClient, superuser_token_headers: dict[str, str]
 ) -> None:
     data = {
         "current_password": settings.FIRST_SUPERUSER_PASSWORD,
@@ -265,14 +282,13 @@ def test_update_password_me_same_password_error(
     )
 
 
-def test_create_user_open(client: TestClient, mocker: MockerFixture) -> None:
+def test_register_user(client: TestClient, db: Session) -> None:
-    mocker.patch("app.core.config.settings.USERS_OPEN_REGISTRATION", True)
     username = random_email()
     password = random_lower_string()
     full_name = random_lower_string()
     data = {"email": username, "password": password, "full_name": full_name}
     r = client.post(
-        f"{settings.API_V1_STR}/users/open",
+        f"{settings.API_V1_STR}/users/signup",
         json=data,
     )
     assert r.status_code == 200
@@ -280,27 +296,15 @@ def test_create_user_open(client: TestClient, mocker: MockerFixture) -> None:
     assert created_user["email"] == username
     assert created_user["full_name"] == full_name
 
-
+    user_query = select(User).where(User.email == username)
-def test_create_user_open_forbidden_error(
+    user_db = db.exec(user_query).first()
-    client: TestClient, mocker: MockerFixture
+    assert user_db
-) -> None:
+    assert user_db.email == username
-    mocker.patch("app.core.config.settings.USERS_OPEN_REGISTRATION", False)
+    assert user_db.full_name == full_name
-    username = random_email()
+    assert verify_password(password, user_db.hashed_password)
-    password = random_lower_string()
-    full_name = random_lower_string()
-    data = {"email": username, "password": password, "full_name": full_name}
-    r = client.post(
-        f"{settings.API_V1_STR}/users/open",
-        json=data,
-    )
-    assert r.status_code == 403
-    assert r.json()["detail"] == "Open user registration is forbidden on this server"
 
 
-def test_create_user_open_already_exists_error(
+def test_register_user_already_exists_error(client: TestClient) -> None:
-    client: TestClient, mocker: MockerFixture
-) -> None:
-    mocker.patch("app.core.config.settings.USERS_OPEN_REGISTRATION", True)
     password = random_lower_string()
     full_name = random_lower_string()
     data = {
@@ -309,7 +313,7 @@ def test_create_user_open_already_exists_error(
         "full_name": full_name,
     }
     r = client.post(
-        f"{settings.API_V1_STR}/users/open",
+        f"{settings.API_V1_STR}/users/signup",
         json=data,
     )
     assert r.status_code == 400
@@ -332,15 +336,22 @@ def test_update_user(
     )
     assert r.status_code == 200
     updated_user = r.json()
+
     assert updated_user["full_name"] == "Updated_full_name"
 
+    user_query = select(User).where(User.email == username)
+    user_db = db.exec(user_query).first()
+    db.refresh(user_db)
+    assert user_db
+    assert user_db.full_name == "Updated_full_name"
+
 
 def test_update_user_not_exists(
-    client: TestClient, superuser_token_headers: dict[str, str], db: Session
+    client: TestClient, superuser_token_headers: dict[str, str]
 ) -> None:
     data = {"full_name": "Updated_full_name"}
     r = client.patch(
-        f"{settings.API_V1_STR}/users/99999999",
+        f"{settings.API_V1_STR}/users/{uuid.uuid4()}",
         headers=superuser_token_headers,
         json=data,
     )
@@ -371,24 +382,7 @@ def test_update_user_email_exists(
     assert r.json()["detail"] == "User with this email already exists"
 
 
-def test_delete_user_super_user(
+def test_delete_user_me(client: TestClient, db: Session) -> None:
-    client: TestClient, superuser_token_headers: dict[str, str], db: Session
-) -> None:
-    username = random_email()
-    password = random_lower_string()
-    user_in = UserCreate(email=username, password=password)
-    user = crud.create_user(session=db, user_create=user_in)
-    user_id = user.id
-    r = client.delete(
-        f"{settings.API_V1_STR}/users/{user_id}",
-        headers=superuser_token_headers,
-    )
-    assert r.status_code == 200
-    deleted_user = r.json()
-    assert deleted_user["message"] == "User deleted successfully"
-
-
-def test_delete_user_current_user(client: TestClient, db: Session) -> None:
     username = random_email()
     password = random_lower_string()
     user_in = UserCreate(email=username, password=password)
@@ -405,19 +399,56 @@ def test_delete_user_current_user(client: TestClient, db: Session) -> None:
     headers = {"Authorization": f"Bearer {a_token}"}
 
     r = client.delete(
-        f"{settings.API_V1_STR}/users/{user_id}",
+        f"{settings.API_V1_STR}/users/me",
         headers=headers,
     )
     assert r.status_code == 200
     deleted_user = r.json()
     assert deleted_user["message"] == "User deleted successfully"
+    result = db.exec(select(User).where(User.id == user_id)).first()
+    assert result is None
+
+    user_query = select(User).where(User.id == user_id)
+    user_db = db.execute(user_query).first()
+    assert user_db is None
+
+
+def test_delete_user_me_as_superuser(
+    client: TestClient, superuser_token_headers: dict[str, str]
+) -> None:
+    r = client.delete(
+        f"{settings.API_V1_STR}/users/me",
+        headers=superuser_token_headers,
+    )
+    assert r.status_code == 403
+    response = r.json()
+    assert response["detail"] == "Super users are not allowed to delete themselves"
+
+
+def test_delete_user_super_user(
+    client: TestClient, superuser_token_headers: dict[str, str], db: Session
+) -> None:
+    username = random_email()
+    password = random_lower_string()
+    user_in = UserCreate(email=username, password=password)
+    user = crud.create_user(session=db, user_create=user_in)
+    user_id = user.id
+    r = client.delete(
+        f"{settings.API_V1_STR}/users/{user_id}",
+        headers=superuser_token_headers,
+    )
+    assert r.status_code == 200
+    deleted_user = r.json()
+    assert deleted_user["message"] == "User deleted successfully"
+    result = db.exec(select(User).where(User.id == user_id)).first()
+    assert result is None
 
 
 def test_delete_user_not_found(
-    client: TestClient, superuser_token_headers: dict[str, str], db: Session
+    client: TestClient, superuser_token_headers: dict[str, str]
 ) -> None:
     r = client.delete(
-        f"{settings.API_V1_STR}/users/99999999",
+        f"{settings.API_V1_STR}/users/{uuid.uuid4()}",
         headers=superuser_token_headers,
     )
     assert r.status_code == 404

backend/app/tests/scripts/test_backend_pre_start.py

@@ -1,33 +1,33 @@
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch
 
-from pytest_mock import MockerFixture
 from sqlmodel import select
 
 from app.backend_pre_start import init, logger
 
 
-def test_init_successful_connection(mocker: MockerFixture) -> None:
+def test_init_successful_connection() -> None:
     engine_mock = MagicMock()
 
     session_mock = MagicMock()
     exec_mock = MagicMock(return_value=True)
     session_mock.configure_mock(**{"exec.return_value": exec_mock})
-    mocker.patch("sqlmodel.Session", return_value=session_mock)
 
-    mocker.patch.object(logger, "info")
+    with (
-    mocker.patch.object(logger, "error")
+        patch("sqlmodel.Session", return_value=session_mock),
-    mocker.patch.object(logger, "warn")
+        patch.object(logger, "info"),
+        patch.object(logger, "error"),
+        patch.object(logger, "warn"),
+    ):
+        try:
+            init(engine_mock)
+            connection_successful = True
+        except Exception:
+            connection_successful = False
 
-    try:
+        assert (
-        init(engine_mock)
+            connection_successful
-        connection_successful = True
+        ), "The database connection should be successful and not raise an exception."
-    except Exception:
-        connection_successful = False
 
-    assert (
+        assert session_mock.exec.called_once_with(
-        connection_successful
+            select(1)
-    ), "The database connection should be successful and not raise an exception."
+        ), "The session should execute a select statement once."
-
-    assert session_mock.exec.called_once_with(
-        select(1)
-    ), "The session should execute a select statement once."

backend/app/tests/scripts/test_test_pre_start.py

@@ -1,33 +1,33 @@
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch
 
-from pytest_mock import MockerFixture
 from sqlmodel import select
 
 from app.tests_pre_start import init, logger
 
 
-def test_init_successful_connection(mocker: MockerFixture) -> None:
+def test_init_successful_connection() -> None:
     engine_mock = MagicMock()
 
     session_mock = MagicMock()
     exec_mock = MagicMock(return_value=True)
     session_mock.configure_mock(**{"exec.return_value": exec_mock})
-    mocker.patch("sqlmodel.Session", return_value=session_mock)
 
-    mocker.patch.object(logger, "info")
+    with (
-    mocker.patch.object(logger, "error")
+        patch("sqlmodel.Session", return_value=session_mock),
-    mocker.patch.object(logger, "warn")
+        patch.object(logger, "info"),
+        patch.object(logger, "error"),
+        patch.object(logger, "warn"),
+    ):
+        try:
+            init(engine_mock)
+            connection_successful = True
+        except Exception:
+            connection_successful = False
 
-    try:
+        assert (
-        init(engine_mock)
+            connection_successful
-        connection_successful = True
+        ), "The database connection should be successful and not raise an exception."
-    except Exception:
-        connection_successful = False
 
-    assert (
+        assert session_mock.exec.called_once_with(
-        connection_successful
+            select(1)
-    ), "The database connection should be successful and not raise an exception."
+        ), "The session should execute a select statement once."
-
-    assert session_mock.exec.called_once_with(
-        select(1)
-    ), "The session should execute a select statement once."

backend/app/utils.py

@@ -1,15 +1,20 @@
 import logging
 from dataclasses import dataclass
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any
 
 import emails  # type: ignore
+import jwt
 from jinja2 import Template
-from jose import JWTError, jwt
+from jwt.exceptions import InvalidTokenError
 
+from app.core import security
 from app.core.config import settings
 
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class EmailData:
@@ -47,7 +52,7 @@ def send_email(
     if settings.SMTP_PASSWORD:
         smtp_options["password"] = settings.SMTP_PASSWORD
     response = message.send(to=email_to, smtp=smtp_options)
-    logging.info(f"send email result: {response}")
+    logger.info(f"send email result: {response}")
 
 
 def generate_test_email(email_to: str) -> EmailData:
@@ -63,7 +68,7 @@ def generate_test_email(email_to: str) -> EmailData:
 def generate_reset_password_email(email_to: str, email: str, token: str) -> EmailData:
     project_name = settings.PROJECT_NAME
     subject = f"{project_name} - Password recovery for user {email}"
-    link = f"{settings.server_host}/reset-password?token={token}"
+    link = f"{settings.FRONTEND_HOST}/reset-password?token={token}"
     html_content = render_email_template(
         template_name="reset_password.html",
         context={
@@ -89,7 +94,7 @@ def generate_new_account_email(
             "username": username,
             "password": password,
             "email": email_to,
-            "link": settings.server_host,
+            "link": settings.FRONTEND_HOST,
         },
     )
     return EmailData(html_content=html_content, subject=subject)
@@ -97,20 +102,22 @@ def generate_new_account_email(
 
 def generate_password_reset_token(email: str) -> str:
     delta = timedelta(hours=settings.EMAIL_RESET_TOKEN_EXPIRE_HOURS)
-    now = datetime.utcnow()
+    now = datetime.now(timezone.utc)
     expires = now + delta
     exp = expires.timestamp()
     encoded_jwt = jwt.encode(
         {"exp": exp, "nbf": now, "sub": email},
         settings.SECRET_KEY,
-        algorithm="HS256",
+        algorithm=security.ALGORITHM,
     )
     return encoded_jwt
 
 
 def verify_password_reset_token(token: str) -> str | None:
     try:
-        decoded_token = jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"])
+        decoded_token = jwt.decode(
+            token, settings.SECRET_KEY, algorithms=[security.ALGORITHM]
+        )
         return str(decoded_token["sub"])
-    except JWTError:
+    except InvalidTokenError:
         return None

backend/pyproject.toml

@@ -1,57 +1,49 @@
-[tool.poetry]
+[project]
 name = "app"
 version = "0.1.0"
 description = ""
-authors = ["Admin <admin@example.com>"]
+requires-python = ">=3.10,<4.0"
+dependencies = [
+    "fastapi[standard]<1.0.0,>=0.114.2",
+    "python-multipart<1.0.0,>=0.0.7",
+    "email-validator<3.0.0.0,>=2.1.0.post1",
+    "passlib[bcrypt]<2.0.0,>=1.7.4",
+    "tenacity<9.0.0,>=8.2.3",
+    "pydantic>2.0",
+    "emails<1.0,>=0.6",
+    "jinja2<4.0.0,>=3.1.4",
+    "alembic<2.0.0,>=1.12.1",
+    "httpx<1.0.0,>=0.25.1",
+    "psycopg[binary]<4.0.0,>=3.1.13",
+    "sqlmodel<1.0.0,>=0.0.21",
+    # Pin bcrypt until passlib supports the latest
+    "bcrypt==4.0.1",
+    "pydantic-settings<3.0.0,>=2.2.1",
+    "sentry-sdk[fastapi]<2.0.0,>=1.40.6",
+    "pyjwt<3.0.0,>=2.8.0",
+]
 
-[tool.poetry.dependencies]
+[tool.uv]
-python = "^3.10"
+dev-dependencies = [
-uvicorn = {extras = ["standard"], version = "^0.24.0.post1"}
+    "pytest<8.0.0,>=7.4.3",
-fastapi = "^0.109.1"
+    "mypy<2.0.0,>=1.8.0",
-python-multipart = "^0.0.7"
+    "ruff<1.0.0,>=0.2.2",
-email-validator = "^2.1.0.post1"
+    "pre-commit<4.0.0,>=3.6.2",
-passlib = {extras = ["bcrypt"], version = "^1.7.4"}
+    "types-passlib<2.0.0.0,>=1.7.7.20240106",
-tenacity = "^8.2.3"
+    "coverage<8.0.0,>=7.4.3",
-pydantic = ">2.0"
+]
-emails = "^0.6"
 
-gunicorn = "^21.2.0"
-jinja2 = "^3.1.2"
-alembic = "^1.12.1"
-python-jose = {extras = ["cryptography"], version = "^3.3.0"}
-httpx = "^0.25.1"
-psycopg = {extras = ["binary"], version = "^3.1.13"}
-sqlmodel = "^0.0.16"
-# Pin bcrypt until passlib supports the latest
-bcrypt = "4.0.1"
-pydantic-settings = "^2.2.1"
-sentry-sdk = {extras = ["fastapi"], version = "^1.40.6"}
-
-[tool.poetry.group.dev.dependencies]
-pytest = "^7.4.3"
-pytest-cov = "^4.1.0"
-mypy = "^1.8.0"
-ruff = "^0.2.2"
-pre-commit = "^3.6.2"
-pytest-mock = "^3.12.0"
-types-python-jose = "^3.3.4.20240106"
-types-passlib = "^1.7.7.20240106"
-
-[tool.isort]
-multi_line_output = 3
-include_trailing_comma = true
-force_grid_wrap = 0
-line_length = 88
 [build-system]
-requires = ["poetry>=0.12"]
+requires = ["hatchling"]
-build-backend = "poetry.masonry.api"
+build-backend = "hatchling.build"
 
 [tool.mypy]
 strict = true
-exclude = ["venv", "alembic"]
+exclude = ["venv", ".venv", "alembic"]
 
 [tool.ruff]
 target-version = "py310"
+exclude = ["alembic"]
 
 [tool.ruff.lint]
 select = [
@@ -62,6 +54,7 @@ select = [
     "B",  # flake8-bugbear
     "C4",  # flake8-comprehensions
     "UP",  # pyupgrade
+    "ARG001", # unused arguments in functions
 ]
 ignore = [
     "E501",  # line too long, handled by black

backend/scripts/format-imports.sh

@@ -1,6 +0,0 @@
-#!/bin/sh -e
-set -x
-
-# Sort imports one per line, so autoflake can remove unused imports
-isort --recursive  --force-single-line-imports --apply app
-sh ./scripts/format.sh

backend/scripts/format.sh

@@ -1,6 +1,5 @@
 #!/bin/sh -e
 set -x
 
-autoflake --remove-all-unused-imports --recursive --remove-unused-variables --in-place app --exclude=__init__.py
+ruff check app scripts --fix
-black app
+ruff format app scripts
-isort --recursive --apply app

backend/scripts/lint.sh

@@ -4,5 +4,5 @@ set -e
 set -x
 
 mypy app
-ruff app
+ruff check app
 ruff format app --check

backend/scripts/prestart.sh

@@ -1,10 +1,13 @@
 #! /usr/bin/env bash
 
+set -e
+set -x
+
 # Let the DB start
-python /app/app/backend_pre_start.py
+python app/backend_pre_start.py
 
 # Run migrations
 alembic upgrade head
 
 # Create initial data in DB
-python /app/app/initial_data.py
+python app/initial_data.py

backend/scripts/test-cov-html.sh

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-set -x
-
-bash scripts/test.sh --cov-report=html "${@}"

backend/scripts/tests-start.sh

@@ -0,0 +1,7 @@
+#! /usr/bin/env bash
+set -e
+set -x
+
+python app/tests_pre_start.py
+
+bash scripts/test.sh "$@"

backend/tests-start.sh

@@ -1,7 +0,0 @@
-#! /usr/bin/env bash
-set -e
-set -x
-
-python /app/app/tests_pre_start.py
-
-bash ./scripts/test.sh "$@"

copier.yml

@@ -63,7 +63,6 @@ _exclude:
   # Global
   - .vscode
   - .mypy_cache
-  - poetry.lock
   # Python
   - __pycache__
   - app.egg-info
@@ -71,7 +70,6 @@ _exclude:
   - .mypy_cache
   - .coverage
   - htmlcov
-  - poetry.lock
   - .cache
   - .venv
   # Frontend
@@ -99,4 +97,4 @@ _exclude:
 _answers_file: .copier/.copier-answers.yml
 
 _tasks:
-  - "python .copier/update_dotenv.py"
+  - ["{{ _copier_python }}", .copier/update_dotenv.py]

deployment.md

@@ -12,7 +12,7 @@ But you have to configure a couple things first. 🤓
 
 * Have a remote server ready and available.
 * Configure the DNS records of your domain to point to the IP of the server you just created.
-* Configure a wildcard subdomain for your domain, so that you can have multiple subdomains for different services, e.g. `*.fastapi-project.example.com`. This will be useful for accessing different components, like `traefik.fastapi-project.example.com`, `adminer.fastapi-project.example.com`, etc. And also for `staging`, like `staging.fastapi-project.example.com`, `staging.adminer.fastapi-project.example.com`, etc.
+* Configure a wildcard subdomain for your domain, so that you can have multiple subdomains for different services, e.g. `*.fastapi-project.example.com`. This will be useful for accessing different components, like `dashboard.fastapi-project.example.com`, `api.fastapi-project.example.com`, `traefik.fastapi-project.example.com`, `adminer.fastapi-project.example.com`, etc. And also for `staging`, like `dashboard.staging.fastapi-project.example.com`, `adminer.staging..fastapi-project.example.com`, etc.
 * Install and configure [Docker](https://docs.docker.com/engine/install/) on the remote server (Docker Engine, not Docker Desktop).
 
 ## Public Traefik
@@ -127,11 +127,12 @@ export DOMAIN=fastapi-project.example.com
 
 You can set several variables, like:
 
+* `PROJECT_NAME`: The name of the project, used in the API for the docs and emails.
+* `STACK_NAME`: The name of the stack used for Docker Compose labels and project name, this should be different for `staging`, `production`, etc. You could use the same domain replacing dots with dashes, e.g. `fastapi-project-example-com` and `staging-fastapi-project-example-com`.
 * `BACKEND_CORS_ORIGINS`: A list of allowed CORS origins separated by commas.
 * `SECRET_KEY`: The secret key for the FastAPI project, used to sign tokens.
 * `FIRST_SUPERUSER`: The email of the first superuser, this superuser will be the one that can create new users.
 * `FIRST_SUPERUSER_PASSWORD`: The password of the first superuser.
-* `USERS_OPEN_REGISTRATION`: Whether to allow open registration of new users.
 * `SMTP_HOST`: The SMTP server host to send emails, this would come from your email provider (E.g. Mailgun, Sparkpost, Sendgrid, etc).
 * `SMTP_USER`: The SMTP server user to send emails.
 * `SMTP_PASSWORD`: The SMTP server password to send emails.
@@ -143,6 +144,13 @@ You can set several variables, like:
 * `POSTGRES_DB`: The database name to use for this application. You can leave the default of `app`.
 * `SENTRY_DSN`: The DSN for Sentry, if you are using it.
 
+## GitHub Actions Environment Variables
+
+There are some environment variables only used by GitHub Actions that you can configure:
+
+* `LATEST_CHANGES`: Used by the GitHub Action [latest-changes](https://github.com/tiangolo/latest-changes) to automatically add release notes based on the PRs merged. It's a personal access token, read the docs for details.
+* `SMOKESHOW_AUTH_KEY`: Used to handle and publish the code coverage using [Smokeshow](https://github.com/samuelcolvin/smokeshow), follow their instructions to create a (free) Smokeshow key.
+
 ### Generate secret keys
 
 Some environment variables in the `.env` file have a default value of `changethis`.
@@ -175,22 +183,22 @@ There are already two environments configured, `staging` and `production`. 🚀
 
 ### Install GitHub Actions Runner
 
-* On your remote server, if you are running as the `root` user, create a user for your GitHub Actions:
+* On your remote server, create a user for your GitHub Actions:
 
 ```bash
-adduser github
+sudo adduser github
 ```
 
 * Add Docker permissions to the `github` user:
 
 ```bash
-usermod -aG docker github
+sudo usermod -aG docker github
 ```
 
 * Temporarily switch to the `github` user:
 
 ```bash
-su - github
+sudo su - github
 ```
 
 * Go to the `github` user's home directory:
@@ -211,9 +219,15 @@ To make sure it runs on startup and continues running, you can install it as a s
 exit
 ```
 
-After you do it, you would be on the `root` user again. And you will be on the previous directory, belonging to the `root` user.
+After you do it, you will be on the previous user again. And you will be on the previous directory, belonging to that user.
 
-* Go to the `actions-runner` directory inside of the `github` user's home directory:
+Before being able to go the `github` user directory, you need to become the `root` user (you might already be):
+
+```bash
+sudo su
+```
+
+* As the `root` user, go to the `actions-runner` directory inside of the `github` user's home directory:
 
 ```bash
 cd /home/github/actions-runner
@@ -247,11 +261,15 @@ The current Github Actions workflows expect these secrets:
 
 * `DOMAIN_PRODUCTION`
 * `DOMAIN_STAGING`
+* `STACK_NAME_PRODUCTION`
+* `STACK_NAME_STAGING`
 * `EMAILS_FROM_EMAIL`
 * `FIRST_SUPERUSER`
 * `FIRST_SUPERUSER_PASSWORD`
 * `POSTGRES_PASSWORD`
 * `SECRET_KEY`
+* `LATEST_CHANGES`
+* `SMOKESHOW_AUTH_KEY`
 
 ## GitHub Action Deployment Workflows
 
@@ -272,20 +290,20 @@ Traefik UI: `https://traefik.fastapi-project.example.com`
 
 ### Production
 
-Frontend: `https://fastapi-project.example.com`
+Frontend: `https://dashboard.fastapi-project.example.com`
 
-Backend API docs: `https://fastapi-project.example.com/docs`
+Backend API docs: `https://api.fastapi-project.example.com/docs`
 
-Backend API base URL: `https://fastapi-project.example.com/api/`
+Backend API base URL: `https://api.fastapi-project.example.com`
 
 Adminer: `https://adminer.fastapi-project.example.com`
 
 ### Staging
 
-Frontend: `https://staging.fastapi-project.example.com`
+Frontend: `https://dashboard.staging.fastapi-project.example.com`
 
-Backend API docs: `https://staging.fastapi-project.example.com/docs`
+Backend API docs: `https://api.staging.fastapi-project.example.com/docs`
 
-Backend API base URL: `https://staging.fastapi-project.example.com/api/`
+Backend API base URL: `https://api.staging.fastapi-project.example.com`
 
-Adminer: `https://staging.adminer.fastapi-project.example.com`
+Adminer: `https://adminer.staging.fastapi-project.example.com`

development.md

@@ -1,77 +1,100 @@
 # FastAPI Project - Development
 
-## Development in `localhost` with a custom domain
+## Docker Compose
 
-You might want to use something different than `localhost` as the domain. For example, if you are having problems with cookies that need a subdomain, and Chrome is not allowing you to use `localhost`.
+* Start the local stack with Docker Compose:
 
-In that case, you have two options: you could use the instructions to modify your system `hosts` file with the instructions below in **Development with a custom IP** or you can just use `localhost.tiangolo.com`, it is set up to point to `localhost` (to the IP `127.0.0.1`) and all its subdomains too. And as it is an actual domain, the browsers will store the cookies you set during development, etc.
+```bash
-
+docker compose watch
-If you used the default CORS enabled domains while generating the project, `localhost.tiangolo.com` was configured to be allowed. If you didn't, you will need to add it to the list in the variable `BACKEND_CORS_ORIGINS` in the `.env` file.
-
-To configure it in your stack, follow the section **Change the development "domain"** below, using the domain `localhost.tiangolo.com`.
-
-After performing those steps you should be able to open: http://localhost.tiangolo.com and it will be served by your stack in `localhost`.
-
-Check all the corresponding available URLs in the section at the end.
-
-## Development with a custom IP
-
-If you are running Docker in an IP address different than `127.0.0.1` (`localhost`), you will need to perform some additional steps. That will be the case if you are running a custom Virtual Machine or your Docker is located in a different machine in your network.
-
-In that case, you will need to use a fake local domain (`dev.example.com`) and make your computer think that the domain is served by the custom IP (e.g. `192.168.99.150`).
-
-If you have a custom domain like that, you need to add it to the list in the variable `BACKEND_CORS_ORIGINS` in the `.env` file.
-
-* Open your `hosts` file with administrative privileges using a text editor:
-  * **Note for Windows**: If you are in Windows, open the main Windows menu, search for "notepad", right click on it, and select the option "open as Administrator" or similar. Then click the "File" menu, "Open file", go to the directory `c:\Windows\System32\Drivers\etc\`, select the option to show "All files" instead of only "Text (.txt) files", and open the `hosts` file.
-  * **Note for Mac and Linux**: Your `hosts` file is probably located at `/etc/hosts`, you can edit it in a terminal running `sudo nano /etc/hosts`.
-
-* Additional to the contents it might have, add a new line with the custom IP (e.g. `192.168.99.150`) a space character, and your fake local domain: `dev.example.com`.
-
-The new line might look like:
-
-```
-192.168.99.150    dev.example.com
 ```
 
-* Save the file.
+* Now you can open your browser and interact with these URLs:
-  * **Note for Windows**: Make sure you save the file as "All files", without an extension of `.txt`. By default, Windows tries to add the extension. Make sure the file is saved as is, without extension.
 
-...that will make your computer think that the fake local domain is served by that custom IP, and when you open that URL in your browser, it will talk directly to your locally running server when it is asked to go to `dev.example.com` and think that it is a remote server while it is actually running in your computer.
+Frontend, built with Docker, with routes handled based on the path: http://localhost:5173
 
-To configure it in your stack, follow the section **Change the development "domain"** below, using the domain `dev.example.com`.
+Backend, JSON based web API based on OpenAPI: http://localhost:8000
 
-After performing those steps you should be able to open: http://dev.example.com and it will be server by your stack in `192.168.99.150`.
+Automatic interactive documentation with Swagger UI (from the OpenAPI backend): http://localhost:8000/docs
 
-Check all the corresponding available URLs in the section at the end.
+Adminer, database web administration: http://localhost:8080
 
-## Change the development "domain"
+Traefik UI, to see how the routes are being handled by the proxy: http://localhost:8090
 
-If you need to use your local stack with a different domain than `localhost`, you need to make sure the domain you use points to the IP where your stack is set up.
+**Note**: The first time you start your stack, it might take a minute for it to be ready. While the backend waits for the database to be ready and configures everything. You can check the logs to monitor it.
 
-To simplify your Docker Compose setup, for example, so that the API docs (Swagger UI) knows where is your API, you should let it know you are using that domain for development.
+To check the logs, run (in another terminal):
 
-* Open the file located at `./.env`. It would have a line like:
+```bash
-
+docker compose logs
-```
-DOMAIN=localhost
 ```
 
-* Change it to the domain you are going to use, e.g.:
+To check the logs of a specific service, add the name of the service, e.g.:
 
+```bash
+docker compose logs backend
 ```
+
+## Local Development
+
+The Docker Compose files are configured so that each of the services is available in a different port in `localhost`.
+
+For the backend and frontend, they use the same port that would be used by their local development server, so, the backend is at `http://localhost:8000` and the frontend at `http://localhost:5173`.
+
+This way, you could turn off a Docker Compose service and start its local development service, and everything would keep working, because it all uses the same ports.
+
+For example, you can stop that `frontend` service in the Docker Compose, in another terminal, run:
+
+```bash
+docker compose stop frontend
+```
+
+And then start the local frontend development server:
+
+```bash
+cd frontend
+npm run dev
+```
+
+Or you could stop the `backend` Docker Compose service:
+
+```bash
+docker compose stop backend
+```
+
+And then you can run the local development server for the backend:
+
+```bash
+cd backend
+fastapi dev app/main.py
+```
+
+## Docker Compose in `localhost.tiangolo.com`
+
+When you start the Docker Compose stack, it uses `localhost` by default, with different ports for each service (backend, frontend, adminer, etc).
+
+When you deploy it to production (or staging), it will deploy each service in a different subdomain, like `api.example.com` for the backend and `dashboard.example.com` for the frontend.
+
+In the guide about [deployment](deployment.md) you can read about Traefik, the configured proxy. That's the component in charge of transmitting traffic to each service based on the subdomain.
+
+If you want to test that it's all working locally, you can edit the local `.env` file, and change:
+
+```dotenv
 DOMAIN=localhost.tiangolo.com
 ```
 
-That variable will be used by the Docker Compose files.
+That will be used by the Docker Compose files to configure the base domain for the services.
 
-After that, you can restart your stack with:
+Traefik will use this to transmit traffic at `api.localhost.tiangolo.com` to the backend, and traffic at `dashboard.localhost.tiangolo.com` to the frontend.
+
+The domain `localhost.tiangolo.com` is a special domain that is configured (with all its subdomains) to point to `127.0.0.1`. This way you can use that for your local development.
+
+After you update it, run again:
 
 ```bash
-docker compose up -d
+docker compose watch
 ```
 
-and check all the corresponding available URLs in the section at the end.
+When deploying, for example in production, the main Traefik is configured outside of the Docker Compose files. For local development, there's an included Traefik in `docker-compose.override.yml`, just to let you test that the domains work as expected, for example with `api.localhost.tiangolo.com` and `dashboard.localhost.tiangolo.com`.
 
 ## Docker Compose files and env vars
 
@@ -83,6 +106,12 @@ These Docker Compose files use the `.env` file containing configurations to be i
 
 They also use some additional configurations taken from environment variables set in the scripts before calling the `docker compose` command.
 
+After changing variables, make sure you restart the stack:
+
+```bash
+docker compose watch
+```
+
 ## The .env file
 
 The `.env` file is the one that contains all your configurations, generated keys and passwords, etc.
@@ -91,6 +120,52 @@ Depending on your workflow, you could want to exclude it from Git, for example i
 
 One way to do it could be to add each environment variable to your CI/CD system, and updating the `docker-compose.yml` file to read that specific env var instead of reading the `.env` file.
 
+## Pre-commits and code linting
+
+we are using a tool called [pre-commit](https://pre-commit.com/) for code linting and formatting.
+
+When you install it, it runs right before making a commit in git. This way it ensures that the code is consistent and formatted even before it is committed.
+
+You can find a file `.pre-commit-config.yaml` with configurations at the root of the project.
+
+#### Install pre-commit to run automatically
+
+`pre-commit` is already part of the dependencies of the project, but you could also install it globally if you prefer to, following [the official pre-commit docs](https://pre-commit.com/).
+
+After having the `pre-commit` tool installed and available, you need to "install" it in the local repository, so that it runs automatically before each commit.
+
+Using `uv`, you could do it with:
+
+```bash
+❯ uv run pre-commit install
+pre-commit installed at .git/hooks/pre-commit
+```
+
+Now whenever you try to commit, e.g. with:
+
+```bash
+git commit
+```
+
+...pre-commit will run and check and format the code you are about to commit, and will ask you to add that code (stage it) with git again before committing.
+
+Then you can `git add` the modified/fixed files again and now you can commit.
+
+#### Running pre-commit hooks manually
+
+you can also run `pre-commit` manually on all the files, you can do it using `uv` with:
+
+```bash
+❯ uv run pre-commit run --all-files
+check for added large files..............................................Passed
+check toml...............................................................Passed
+check yaml...............................................................Passed
+ruff.....................................................................Passed
+ruff-format..............................................................Passed
+eslint...................................................................Passed
+prettier.................................................................Passed
+```
+
 ## URLs
 
 The production or staging URLs would use these same paths, but with your own domain.
@@ -99,30 +174,34 @@ The production or staging URLs would use these same paths, but with your own dom
 
 Development URLs, for local development.
 
-Frontend: http://localhost
+Frontend: http://localhost:5173
 
-Backend: http://localhost/api/
+Backend: http://localhost:8000
 
-Automatic Interactive Docs (Swagger UI): https://localhost/docs
+Automatic Interactive Docs (Swagger UI): http://localhost:8000/docs
 
-Automatic Alternative Docs (ReDoc): https://localhost/redoc
+Automatic Alternative Docs (ReDoc): http://localhost:8000/redoc
 
 Adminer: http://localhost:8080
 
 Traefik UI: http://localhost:8090
 
-### Development in localhost with a custom domain URLs
+MailCatcher: http://localhost:1080
+
+### Development URLs with `localhost.tiangolo.com` Configured
 
 Development URLs, for local development.
 
-Frontend: http://localhost.tiangolo.com
+Frontend: http://dashboard.localhost.tiangolo.com
 
-Backend: http://localhost.tiangolo.com/api/
+Backend: http://api.localhost.tiangolo.com
 
-Automatic Interactive Docs (Swagger UI): https://localhost.tiangolo.com/docs
+Automatic Interactive Docs (Swagger UI): http://api.localhost.tiangolo.com/docs
 
-Automatic Alternative Docs (ReDoc): https://localhost.tiangolo.com/redoc
+Automatic Alternative Docs (ReDoc): http://api.localhost.tiangolo.com/redoc
 
 Adminer: http://localhost.tiangolo.com:8080
 
 Traefik UI: http://localhost.tiangolo.com:8090
+
+MailCatcher: http://localhost.tiangolo.com:1080

docker-compose.override.yml

@@ -1,8 +1,12 @@
-version: "3.3"
 services:
 
+  # Local services are available on their ports, but also available on:
+  # http://api.localhost.tiangolo.com: backend
+  # http://dashboard.localhost.tiangolo.com: frontend
+  # etc. To enable it, update .env, set:
+  # DOMAIN=localhost.tiangolo.com
   proxy:
-    image: traefik:v2.3
+    image: traefik:3.0
     volumes:
       - /var/run/docker.sock:/var/run/docker.sock
     ports:
@@ -37,6 +41,9 @@ services:
       # Dummy https-redirect middleware that doesn't really redirect, only to
       # allow running it locally
       - traefik.http.middlewares.https-redirect.contenttype.autodetect=false
+    networks:
+      - traefik-public
+      - default
 
   db:
     restart: "no"
@@ -51,24 +58,75 @@ services:
   backend:
     restart: "no"
     ports:
-      - "8888:8888"
+      - "8000:8000"
-    volumes:
-      - ./backend/:/app
     build:
       context: ./backend
-      args:
-        INSTALL_DEV: ${INSTALL_DEV-true}
     # command: sleep infinity  # Infinite loop to keep container alive doing nothing
-    command: /start-reload.sh
+    command:
+      - fastapi
+      - run
+      - --reload
+      - "app/main.py"
+    develop:
+      watch:
+        - path: ./backend
+          action: sync
+          target: /app
+          ignore:
+            - ./backend/.venv
+            - .venv
+        - path: ./backend/pyproject.toml
+          action: rebuild
+    # TODO: remove once coverage is done locally
+    volumes:
+      - ./backend/htmlcov:/app/htmlcov
+    environment:
+      SMTP_HOST: "mailcatcher"
+      SMTP_PORT: "1025"
+      SMTP_TLS: "false"
+      EMAILS_FROM_EMAIL: "noreply@example.com"
+
+  mailcatcher:
+    image: schickling/mailcatcher
+    ports:
+      - "1080:1080"
+      - "1025:1025"
 
   frontend:
     restart: "no"
+    ports:
+      - "5173:80"
     build:
       context: ./frontend
       args:
-        - VITE_API_URL=http://${DOMAIN?Variable not set}
+        - VITE_API_URL=http://localhost:8000
         - NODE_ENV=development
 
+  playwright:
+    build:
+      context: ./frontend
+      dockerfile: Dockerfile.playwright
+      args:
+        - VITE_API_URL=http://backend:8000
+        - NODE_ENV=production
+    ipc: host
+    depends_on:
+      - backend
+      - mailcatcher
+    env_file:
+      - .env
+    environment:
+      - VITE_API_URL=http://backend:8000
+      - MAILCATCHER_HOST=http://mailcatcher:1080
+      # For the reports when run locally
+      - PLAYWRIGHT_HTML_HOST=0.0.0.0
+      - CI=${CI}
+    volumes:
+      - ./frontend/blob-report:/app/blob-report
+      - ./frontend/test-results:/app/test-results
+    ports:
+      - 9323:9323
+
 networks:
   traefik-public:
     # For local dev, don't expect an external Traefik network

docker-compose.traefik.yml

@@ -1,6 +1,6 @@
 services:
   traefik:
-    image: traefik:v2.3
+    image: traefik:3.0
     ports:
       # Listen on port 80, default for HTTP, necessary to redirect to HTTPS
       - 80:80

docker-compose.yml

@@ -1,8 +1,14 @@
-version: "3.3"
 services:
+
   db:
     image: postgres:12
     restart: always
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
+      interval: 10s
+      retries: 5
+      start_period: 30s
+      timeout: 10s
     volumes:
       - app-db-data:/var/lib/postgresql/data/pgdata
     env_file:
@@ -36,24 +42,28 @@ services:
       - traefik.http.routers.${STACK_NAME?Variable not set}-adminer-https.tls.certresolver=le
       - traefik.http.services.${STACK_NAME?Variable not set}-adminer.loadbalancer.server.port=8080
 
-  backend:
+  prestart:
     image: '${DOCKER_IMAGE_BACKEND?Variable not set}:${TAG-latest}'
-    restart: always
+    build:
+      context: ./backend
     networks:
       - traefik-public
       - default
     depends_on:
-      - db
+      db:
+        condition: service_healthy
+        restart: true
+    command: bash scripts/prestart.sh
     env_file:
       - .env
     environment:
       - DOMAIN=${DOMAIN}
+      - FRONTEND_HOST=${FRONTEND_HOST?Variable not set}
       - ENVIRONMENT=${ENVIRONMENT}
       - BACKEND_CORS_ORIGINS=${BACKEND_CORS_ORIGINS}
       - SECRET_KEY=${SECRET_KEY?Variable not set}
       - FIRST_SUPERUSER=${FIRST_SUPERUSER?Variable not set}
       - FIRST_SUPERUSER_PASSWORD=${FIRST_SUPERUSER_PASSWORD?Variable not set}
-      - USERS_OPEN_REGISTRATION=${USERS_OPEN_REGISTRATION}
       - SMTP_HOST=${SMTP_HOST}
       - SMTP_USER=${SMTP_USER}
       - SMTP_PASSWORD=${SMTP_PASSWORD}
@@ -65,27 +75,64 @@ services:
       - POSTGRES_PASSWORD=${POSTGRES_PASSWORD?Variable not set}
       - SENTRY_DSN=${SENTRY_DSN}
 
+  backend:
+    image: '${DOCKER_IMAGE_BACKEND?Variable not set}:${TAG-latest}'
+    restart: always
+    networks:
+      - traefik-public
+      - default
+    depends_on:
+      db:
+        condition: service_healthy
+        restart: true
+      prestart:
+        condition: service_completed_successfully
+    env_file:
+      - .env
+    environment:
+      - DOMAIN=${DOMAIN}
+      - FRONTEND_HOST=${FRONTEND_HOST?Variable not set}
+      - ENVIRONMENT=${ENVIRONMENT}
+      - BACKEND_CORS_ORIGINS=${BACKEND_CORS_ORIGINS}
+      - SECRET_KEY=${SECRET_KEY?Variable not set}
+      - FIRST_SUPERUSER=${FIRST_SUPERUSER?Variable not set}
+      - FIRST_SUPERUSER_PASSWORD=${FIRST_SUPERUSER_PASSWORD?Variable not set}
+      - SMTP_HOST=${SMTP_HOST}
+      - SMTP_USER=${SMTP_USER}
+      - SMTP_PASSWORD=${SMTP_PASSWORD}
+      - EMAILS_FROM_EMAIL=${EMAILS_FROM_EMAIL}
+      - POSTGRES_SERVER=db
+      - POSTGRES_PORT=${POSTGRES_PORT}
+      - POSTGRES_DB=${POSTGRES_DB}
+      - POSTGRES_USER=${POSTGRES_USER?Variable not set}
+      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD?Variable not set}
+      - SENTRY_DSN=${SENTRY_DSN}
+
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8000/api/v1/utils/health-check/"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
     build:
       context: ./backend
-      args:
-        INSTALL_DEV: ${INSTALL_DEV-false}
     labels:
       - traefik.enable=true
       - traefik.docker.network=traefik-public
       - traefik.constraint-label=traefik-public
 
-      - traefik.http.services.${STACK_NAME?Variable not set}-backend.loadbalancer.server.port=80
+      - traefik.http.services.${STACK_NAME?Variable not set}-backend.loadbalancer.server.port=8000
 
-      - traefik.http.routers.${STACK_NAME?Variable not set}-backend-http.rule=Host(`${DOMAIN?Variable not set}`, `www.${DOMAIN?Variable not set}`) && PathPrefix(`/api`, `/docs`, `/redoc`)
+      - traefik.http.routers.${STACK_NAME?Variable not set}-backend-http.rule=Host(`api.${DOMAIN?Variable not set}`)
       - traefik.http.routers.${STACK_NAME?Variable not set}-backend-http.entrypoints=http
 
-      - traefik.http.routers.${STACK_NAME?Variable not set}-backend-https.rule=Host(`${DOMAIN?Variable not set}`, `www.${DOMAIN?Variable not set}`) && PathPrefix(`/api`, `/docs`, `/redoc`)
+      - traefik.http.routers.${STACK_NAME?Variable not set}-backend-https.rule=Host(`api.${DOMAIN?Variable not set}`)
       - traefik.http.routers.${STACK_NAME?Variable not set}-backend-https.entrypoints=https
       - traefik.http.routers.${STACK_NAME?Variable not set}-backend-https.tls=true
       - traefik.http.routers.${STACK_NAME?Variable not set}-backend-https.tls.certresolver=le
 
-      - traefik.http.routers.${STACK_NAME?Variable not set}-backend-http.middlewares=https-redirect,${STACK_NAME?Variable not set}-www-redirect
+      # Enable redirection for HTTP and HTTPS
-      - traefik.http.routers.${STACK_NAME?Variable not set}-backend-https.middlewares=${STACK_NAME?Variable not set}-www-redirect
+      - traefik.http.routers.${STACK_NAME?Variable not set}-backend-http.middlewares=https-redirect
 
   frontend:
     image: '${DOCKER_IMAGE_FRONTEND?Variable not set}:${TAG-latest}'
@@ -96,7 +143,7 @@ services:
     build:
       context: ./frontend
       args:
-        - VITE_API_URL=https://${DOMAIN?Variable not set}
+        - VITE_API_URL=https://api.${DOMAIN?Variable not set}
         - NODE_ENV=production
     labels:
       - traefik.enable=true
@@ -105,25 +152,16 @@ services:
 
       - traefik.http.services.${STACK_NAME?Variable not set}-frontend.loadbalancer.server.port=80
 
-      - traefik.http.routers.${STACK_NAME?Variable not set}-frontend-http.rule=Host(`${DOMAIN?Variable not set}`, `www.${DOMAIN?Variable not set}`)
+      - traefik.http.routers.${STACK_NAME?Variable not set}-frontend-http.rule=Host(`dashboard.${DOMAIN?Variable not set}`)
       - traefik.http.routers.${STACK_NAME?Variable not set}-frontend-http.entrypoints=http
 
-      - traefik.http.routers.${STACK_NAME?Variable not set}-frontend-https.rule=Host(`${DOMAIN?Variable not set}`, `www.${DOMAIN?Variable not set}`)
+      - traefik.http.routers.${STACK_NAME?Variable not set}-frontend-https.rule=Host(`dashboard.${DOMAIN?Variable not set}`)
       - traefik.http.routers.${STACK_NAME?Variable not set}-frontend-https.entrypoints=https
       - traefik.http.routers.${STACK_NAME?Variable not set}-frontend-https.tls=true
       - traefik.http.routers.${STACK_NAME?Variable not set}-frontend-https.tls.certresolver=le
 
-      # Handle domain with and without "www" to redirect to only one
+      # Enable redirection for HTTP and HTTPS
-      # To disable www redirection remove the next line
+      - traefik.http.routers.${STACK_NAME?Variable not set}-frontend-http.middlewares=https-redirect
-      - traefik.http.middlewares.${STACK_NAME?Variable not set}-www-redirect.redirectregex.regex=^http(s)?://www.(${DOMAIN?Variable not set})/(.*)
-      # Redirect a domain with www to non-www
-      # To disable it remove the next line
-      - traefik.http.middlewares.${STACK_NAME?Variable not set}-www-redirect.redirectregex.replacement=http$${1}://${DOMAIN?Variable not set}/$${3}
-      # Middleware to redirect www, to disable it remove the next line
-      - traefik.http.routers.${STACK_NAME?Variable not set}-frontend-https.middlewares=${STACK_NAME?Variable not set}-www-redirect
-      # Middleware to redirect www, and redirect HTTP to HTTPS
-      # to disable www redirection remove the section: ${STACK_NAME?Variable not set}-www-redirect,
-      - traefik.http.routers.${STACK_NAME?Variable not set}-frontend-http.middlewares=https-redirect,${STACK_NAME?Variable not set}-www-redirect
 volumes:
   app-db-data:
 

frontend/.env

@@ -1 +1,2 @@
-VITE_API_URL=http://localhost
+VITE_API_URL=http://localhost:8000
+MAILCATCHER_HOST=http://localhost:1080

frontend/.eslintrc.cjs

@@ -1,18 +0,0 @@
-module.exports = {
-  root: true,
-  env: { browser: true, es2020: true },
-  extends: [
-    'eslint:recommended',
-    'plugin:@typescript-eslint/recommended',
-    'plugin:react-hooks/recommended',
-  ],
-  ignorePatterns: ['dist', '.eslintrc.cjs'],
-  parser: '@typescript-eslint/parser',
-  plugins: ['react-refresh'],
-  rules: {
-    'react-refresh/only-export-components': [
-      'warn',
-      { allowConstantExport: true },
-    ],
-  },
-}

frontend/.gitignore

@@ -23,3 +23,8 @@ openapi.json
 *.njsproj
 *.sln
 *.sw?
+/test-results/
+/playwright-report/
+/blob-report/
+/playwright/.cache/
+/playwright/.auth/

frontend/.nvmrc

@@ -1 +1 @@
-18.x.x
+20

frontend/.prettierignore

@@ -1 +0,0 @@
-src/client/

frontend/.prettierrc

@@ -1,8 +0,0 @@
-{
-  "bracketSpacing": true,
-  "semi": false,
-  "singleQuote": true,
-  "trailingComma": "all",
-  "printWidth": 80,
-  "tabWidth": 2
-}

frontend/Dockerfile

@@ -1,5 +1,5 @@
 # Stage 0, "build-stage", based on Node.js, to build and compile the frontend
-FROM node:20 as build-stage
+FROM node:20 AS build-stage
 
 WORKDIR /app
 

frontend/Dockerfile.playwright

@@ -0,0 +1,13 @@
+FROM node:20
+
+WORKDIR /app
+
+COPY package*.json /app/
+
+RUN npm install
+
+RUN npx -y playwright install --with-deps
+
+COPY ./ /app/
+
+ARG VITE_API_URL=${VITE_API_URL}

frontend/README.md

@@ -4,7 +4,7 @@ The frontend is built with [Vite](https://vitejs.dev/), [React](https://reactjs.
 
 ## Frontend development
 
-Before you begin, ensure that you have either the Node Version Manager (nvm) or Fast Node Manager (fnm) installed on your system. 
+Before you begin, ensure that you have either the Node Version Manager (nvm) or Fast Node Manager (fnm) installed on your system.
 
 * To install fnm follow the [official fnm guide](https://github.com/Schniz/fnm#installation). If you prefer nvm, you can install it using the [official nvm guide](https://github.com/nvm-sh/nvm#installing-and-updating).
 
@@ -27,7 +27,7 @@ nvm install
 
 ```bash
 # If using fnm
-fnm use 
+fnm use
 
 # If using nvm
 nvm use
@@ -59,7 +59,7 @@ If you are developing an API-only app and want to remove the frontend, you can d
 
 * In the `docker-compose.yml` file, remove the whole service / section `frontend`.
 
-* In the `docker-compose.override.yml` file, remove the whole service / section `frontend`.
+* In the `docker-compose.override.yml` file, remove the whole service / section `frontend` and `playwright`.
 
 Done, you have a frontend-less (api-only) app. 🤓
 
@@ -74,16 +74,23 @@ But it would be only to clean them up, leaving them won't really have any effect
 
 ## Generate Client
 
+### Automatically
+
+* Activate the backend virtual environment.
+* From the top level project directory, run the script:
+
+```bash
+./scripts/generate-client.sh
+```
+
+* Commit the changes.
+
+### Manually
+
 * Start the Docker Compose stack.
 
 * Download the OpenAPI JSON file from `http://localhost/api/v1/openapi.json` and copy it to a new file `openapi.json` at the root of the `frontend` directory.
 
-* To simplify the names in the generated frontend client code, modify the `openapi.json` file by running the following script:
-
-```bash
-node modify-openapi-operationids.js
-```
-
 * To generate the frontend client, run:
 
 ```bash
@@ -99,7 +106,7 @@ Notice that everytime the backend changes (changing the OpenAPI schema), you sho
 If you want to use a remote API, you can set the environment variable `VITE_API_URL` to the URL of the remote API. For example, you can set it in the `frontend/.env` file:
 
 ```env
-VITE_API_URL=https://my-remote-api.example.com
+VITE_API_URL=https://api.my-domain.example.com
 ```
 
 Then, when you run the frontend, it will use that URL as the base URL for the API.
@@ -115,3 +122,33 @@ The frontend code is structured as follows:
 * `frontend/src/hooks` - Custom hooks.
 * `frontend/src/routes` - The different routes of the frontend which include the pages.
 * `theme.tsx` - The Chakra UI custom theme.
+
+## End-to-End Testing with Playwright
+
+The frontend includes initial end-to-end tests using Playwright. To run the tests, you need to have the Docker Compose stack running. Start the stack with the following command:
+
+```bash
+docker compose up -d --wait backend
+```
+
+Then, you can run the tests with the following command:
+
+```bash
+npx playwright test
+```
+
+You can also run your tests in UI mode to see the browser and interact with it running:
+
+```bash
+npx playwright test --ui
+```
+
+To stop and remove the Docker Compose stack and clean the data created in tests, use the following command:
+
+```bash
+docker compose down -v
+```
+
+To update the tests, navigate to the tests directory and modify the existing test files or add new ones as needed.
+
+For more information on writing and running Playwright tests, refer to the official [Playwright documentation](https://playwright.dev/docs/intro).

frontend/biome.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.6.1/schema.json",
+  "organizeImports": {
+    "enabled": true
+  },
+  "files": {
+    "ignore": [
+      "node_modules",
+      "src/routeTree.gen.ts",
+      "playwright.config.ts",
+      "playwright-report"
+    ]
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true,
+      "suspicious": {
+        "noExplicitAny": "off",
+        "noArrayIndexKey": "off"
+      },
+      "style": {
+        "noNonNullAssertion": "off"
+      }
+    }
+  },
+  "formatter": {
+    "indentStyle": "space"
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "double",
+      "semicolons": "asNeeded"
+    }
+  }
+}

frontend/index.html

@@ -5,7 +5,7 @@
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Full Stack FastAPI Project</title>
-    <link rel="icon" type="image/x-icon" href="./src/assets/images/favicon.png" />
+    <link rel="icon" type="image/x-icon" href="/assets/images/favicon.png" />
   </head>
   <body>
     <div id="root"></div>

frontend/modify-openapi-operationids.js

@@ -1,29 +0,0 @@
-import * as fs from "fs";
-
-const filePath = "./openapi.json";
-
-fs.readFile(filePath, (err, data) => {
-  const openapiContent = JSON.parse(data);
-  if (err) throw err;
-
-  const paths = openapiContent.paths;
-
-  Object.keys(paths).forEach((pathKey) => {
-    const pathData = paths[pathKey];
-    Object.keys(pathData).forEach((method) => {
-      const operation = pathData[method];
-      if (operation.tags && operation.tags.length > 0) {
-        const tag = operation.tags[0];
-        const operationId = operation.operationId;
-        const toRemove = `${tag}-`;
-        if (operationId.startsWith(toRemove)) {
-          const newOperationId = operationId.substring(toRemove.length);
-          operation.operationId = newOperationId;
-        }
-      }
-    });
-  });
-  fs.writeFile(filePath, JSON.stringify(openapiContent, null, 2), (err) => {
-    if (err) throw err;
-  });
-});

frontend/nginx.conf

@@ -4,7 +4,7 @@ server {
   location / {
     root /usr/share/nginx/html;
     index index.html index.htm;
-    try_files $uri $uri/ /index.html =404;
+    try_files $uri /index.html =404;
   }
 
   include /etc/nginx/extra-conf.d/*.conf;

frontend/openapi-ts.config.ts

@@ -0,0 +1,28 @@
+import { defineConfig } from "@hey-api/openapi-ts"
+
+export default defineConfig({
+  client: "legacy/axios",
+  input: "./openapi.json",
+  output: "./src/client",
+  // exportSchemas: true,
+  plugins: [
+    {
+      name: "@hey-api/sdk",
+      // NOTE: this doesn't allow tree-shaking
+      asClass: true,
+      operationId: true,
+      methodNameBuilder: (operation) => {
+        // @ts-ignore
+        let name: string = operation.name
+        // @ts-ignore
+        const service: string = operation.service
+
+        if (service && name.toLowerCase().startsWith(service.toLowerCase())) {
+          name = name.slice(service.length)
+        }
+
+        return name.charAt(0).toLowerCase() + name.slice(1)
+      },
+    },
+  ],
+})

frontend/package.json

@@ -5,43 +5,38 @@
   "type": "module",
   "scripts": {
     "dev": "vite",
-    "build": "tsc && vite build",
+    "build": "tsc -p tsconfig.build.json && vite build",
-    "lint": "eslint ./src --ext .ts,.tsx --fix",
+    "lint": "biome check --apply-unsafe --no-errors-on-unmatched --files-ignore-unknown=true ./",
-    "format": "prettier --write ./src/**/*.{ts,tsx,js,jsx,json,md} --ignore-path .prettierignore",
     "preview": "vite preview",
-    "generate-client": "openapi --input ./openapi.json --useOptions --useUnionTypes --output ./src/client --client axios --exportSchemas true"
+    "generate-client": "openapi-ts"
   },
   "dependencies": {
-    "@chakra-ui/icons": "2.1.1",
+    "@chakra-ui/react": "^3.8.0",
-    "@chakra-ui/react": "2.8.2",
+    "@emotion/react": "^11.14.0",
-    "@emotion/react": "11.11.3",
+    "@tanstack/react-query": "^5.28.14",
-    "@emotion/styled": "11.11.0",
+    "@tanstack/react-query-devtools": "^5.28.14",
     "@tanstack/react-router": "1.19.1",
-    "axios": "1.6.2",
+    "axios": "1.7.4",
     "form-data": "4.0.0",
-    "framer-motion": "10.16.16",
+    "next-themes": "^0.4.4",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
+    "react-error-boundary": "^4.0.13",
     "react-hook-form": "7.49.3",
-    "react-icons": "5.0.1",
+    "react-icons": "^5.4.0"
-    "react-query": "3.39.3",
-    "zustand": "4.5.0"
   },
   "devDependencies": {
+    "@biomejs/biome": "1.6.1",
+    "@hey-api/openapi-ts": "^0.57.0",
+    "@playwright/test": "^1.45.2",
     "@tanstack/router-devtools": "1.19.1",
     "@tanstack/router-vite-plugin": "1.19.0",
-    "@types/node": "20.10.5",
+    "@types/node": "^20.10.5",
     "@types/react": "^18.2.37",
     "@types/react-dom": "^18.2.15",
-    "@typescript-eslint/eslint-plugin": "^6.10.0",
-    "@typescript-eslint/parser": "^6.10.0",
     "@vitejs/plugin-react-swc": "^3.5.0",
-    "eslint": "^8.53.0",
+    "dotenv": "^16.4.5",
-    "eslint-plugin-react-hooks": "^4.6.0",
-    "eslint-plugin-react-refresh": "^0.4.4",
-    "openapi-typescript-codegen": "0.25.0",
-    "prettier": "3.2.5",
     "typescript": "^5.2.2",
-    "vite": "^5.0.12"
+    "vite": "^5.4.14"
   }
 }

frontend/playwright.config.ts

@@ -0,0 +1,91 @@
+import { defineConfig, devices } from '@playwright/test';
+import 'dotenv/config'
+
+/**
+ * Read environment variables from file.
+ * https://github.com/motdotla/dotenv
+ */
+
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+export default defineConfig({
+  testDir: './tests',
+  /* Run tests in files in parallel */
+  fullyParallel: true,
+  /* Fail the build on CI if you accidentally left test.only in the source code. */
+  forbidOnly: !!process.env.CI,
+  /* Retry on CI only */
+  retries: process.env.CI ? 2 : 0,
+  /* Opt out of parallel tests on CI. */
+  workers: process.env.CI ? 1 : undefined,
+  /* Reporter to use. See https://playwright.dev/docs/test-reporters */
+  reporter: process.env.CI ? 'blob' : 'html',
+  /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+  use: {
+    /* Base URL to use in actions like `await page.goto('/')`. */
+    baseURL: 'http://localhost:5173',
+
+    /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+    trace: 'on-first-retry',
+  },
+
+  /* Configure projects for major browsers */
+  projects: [
+    { name: 'setup', testMatch: /.*\.setup\.ts/ },
+
+    {
+      name: 'chromium',
+      use: {
+        ...devices['Desktop Chrome'],
+        storageState: 'playwright/.auth/user.json',
+      },
+      dependencies: ['setup'],
+    },
+
+    // {
+    //   name: 'firefox',
+    //   use: {
+    //     ...devices['Desktop Firefox'],
+    //     storageState: 'playwright/.auth/user.json',
+    //   },
+    //   dependencies: ['setup'],
+    // },
+
+    // {
+    //   name: 'webkit',
+    //   use: {
+    //     ...devices['Desktop Safari'],
+    //     storageState: 'playwright/.auth/user.json',
+    //   },
+    //   dependencies: ['setup'],
+    // },
+
+    /* Test against mobile viewports. */
+    // {
+    //   name: 'Mobile Chrome',
+    //   use: { ...devices['Pixel 5'] },
+    // },
+    // {
+    //   name: 'Mobile Safari',
+    //   use: { ...devices['iPhone 12'] },
+    // },
+
+    /* Test against branded browsers. */
+    // {
+    //   name: 'Microsoft Edge',
+    //   use: { ...devices['Desktop Edge'], channel: 'msedge' },
+    // },
+    // {
+    //   name: 'Google Chrome',
+    //   use: { ...devices['Desktop Chrome'], channel: 'chrome' },
+    // },
+  ],
+
+  /* Run your local dev server before starting the tests */
+  webServer: {
+    command: 'npm run dev',
+    url: 'http://localhost:5173',
+    reuseExistingServer: !process.env.CI,
+  },
+});

frontend/src/client/core/ApiError.ts

@@ -1,25 +1,25 @@
-/* generated using openapi-typescript-codegen -- do no edit */
+import type { ApiRequestOptions } from "./ApiRequestOptions"
-/* istanbul ignore file */
+import type { ApiResult } from "./ApiResult"
-/* tslint:disable */
-/* eslint-disable */
-import type { ApiRequestOptions } from './ApiRequestOptions';
-import type { ApiResult } from './ApiResult';
 
 export class ApiError extends Error {
-    public readonly url: string;
+  public readonly url: string
-    public readonly status: number;
+  public readonly status: number
-    public readonly statusText: string;
+  public readonly statusText: string
-    public readonly body: any;
+  public readonly body: unknown
-    public readonly request: ApiRequestOptions;
+  public readonly request: ApiRequestOptions
 
-    constructor(request: ApiRequestOptions, response: ApiResult, message: string) {
+  constructor(
-        super(message);
+    request: ApiRequestOptions,
+    response: ApiResult,
+    message: string,
+  ) {
+    super(message)
 
-        this.name = 'ApiError';
+    this.name = "ApiError"
-        this.url = response.url;
+    this.url = response.url
-        this.status = response.status;
+    this.status = response.status
-        this.statusText = response.statusText;
+    this.statusText = response.statusText
-        this.body = response.body;
+    this.body = response.body
-        this.request = request;
+    this.request = request
-    }
+  }
 }

frontend/src/client/core/ApiRequestOptions.ts

@@ -1,17 +1,21 @@
-/* generated using openapi-typescript-codegen -- do no edit */
+export type ApiRequestOptions<T = unknown> = {
-/* istanbul ignore file */
+  readonly body?: any
-/* tslint:disable */
+  readonly cookies?: Record<string, unknown>
-/* eslint-disable */
+  readonly errors?: Record<number | string, string>
-export type ApiRequestOptions = {
+  readonly formData?: Record<string, unknown> | any[] | Blob | File
-    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+  readonly headers?: Record<string, unknown>
-    readonly url: string;
+  readonly mediaType?: string
-    readonly path?: Record<string, any>;
+  readonly method:
-    readonly cookies?: Record<string, any>;
+    | "DELETE"
-    readonly headers?: Record<string, any>;
+    | "GET"
-    readonly query?: Record<string, any>;
+    | "HEAD"
-    readonly formData?: Record<string, any>;
+    | "OPTIONS"
-    readonly body?: any;
+    | "PATCH"
-    readonly mediaType?: string;
+    | "POST"
-    readonly responseHeader?: string;
+    | "PUT"
-    readonly errors?: Record<number, string>;
+  readonly path?: Record<string, unknown>
-};
+  readonly query?: Record<string, unknown>
+  readonly responseHeader?: string
+  readonly responseTransformer?: (data: unknown) => Promise<T>
+  readonly url: string
+}

frontend/src/client/core/ApiResult.ts

@@ -1,11 +1,7 @@
-/* generated using openapi-typescript-codegen -- do no edit */
+export type ApiResult<TData = any> = {
-/* istanbul ignore file */
+  readonly body: TData
-/* tslint:disable */
+  readonly ok: boolean
-/* eslint-disable */
+  readonly status: number
-export type ApiResult = {
+  readonly statusText: string
-    readonly url: string;
+  readonly url: string
-    readonly ok: boolean;
+}
-    readonly status: number;
-    readonly statusText: string;
-    readonly body: any;
-};

frontend/src/client/core/CancelablePromise.ts

@@ -1,131 +1,126 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
 export class CancelError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = "CancelError"
+  }
 
-    constructor(message: string) {
+  public get isCancelled(): boolean {
-        super(message);
+    return true
-        this.name = 'CancelError';
+  }
-    }
-
-    public get isCancelled(): boolean {
-        return true;
-    }
 }
 
 export interface OnCancel {
-    readonly isResolved: boolean;
+  readonly isResolved: boolean
-    readonly isRejected: boolean;
+  readonly isRejected: boolean
-    readonly isCancelled: boolean;
+  readonly isCancelled: boolean
 
-    (cancelHandler: () => void): void;
+  (cancelHandler: () => void): void
 }
 
 export class CancelablePromise<T> implements Promise<T> {
-    #isResolved: boolean;
+  private _isResolved: boolean
-    #isRejected: boolean;
+  private _isRejected: boolean
-    #isCancelled: boolean;
+  private _isCancelled: boolean
-    readonly #cancelHandlers: (() => void)[];
+  readonly cancelHandlers: (() => void)[]
-    readonly #promise: Promise<T>;
+  readonly promise: Promise<T>
-    #resolve?: (value: T | PromiseLike<T>) => void;
+  private _resolve?: (value: T | PromiseLike<T>) => void
-    #reject?: (reason?: any) => void;
+  private _reject?: (reason?: unknown) => void
 
-    constructor(
+  constructor(
-        executor: (
+    executor: (
-            resolve: (value: T | PromiseLike<T>) => void,
+      resolve: (value: T | PromiseLike<T>) => void,
-            reject: (reason?: any) => void,
+      reject: (reason?: unknown) => void,
-            onCancel: OnCancel
+      onCancel: OnCancel,
-        ) => void
+    ) => void,
-    ) {
+  ) {
-        this.#isResolved = false;
+    this._isResolved = false
-        this.#isRejected = false;
+    this._isRejected = false
-        this.#isCancelled = false;
+    this._isCancelled = false
-        this.#cancelHandlers = [];
+    this.cancelHandlers = []
-        this.#promise = new Promise<T>((resolve, reject) => {
+    this.promise = new Promise<T>((resolve, reject) => {
-            this.#resolve = resolve;
+      this._resolve = resolve
-            this.#reject = reject;
+      this._reject = reject
 
-            const onResolve = (value: T | PromiseLike<T>): void => {
+      const onResolve = (value: T | PromiseLike<T>): void => {
-                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
-                    return;
+          return
-                }
-                this.#isResolved = true;
-                this.#resolve?.(value);
-            };
-
-            const onReject = (reason?: any): void => {
-                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
-                    return;
-                }
-                this.#isRejected = true;
-                this.#reject?.(reason);
-            };
-
-            const onCancel = (cancelHandler: () => void): void => {
-                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
-                    return;
-                }
-                this.#cancelHandlers.push(cancelHandler);
-            };
-
-            Object.defineProperty(onCancel, 'isResolved', {
-                get: (): boolean => this.#isResolved,
-            });
-
-            Object.defineProperty(onCancel, 'isRejected', {
-                get: (): boolean => this.#isRejected,
-            });
-
-            Object.defineProperty(onCancel, 'isCancelled', {
-                get: (): boolean => this.#isCancelled,
-            });
-
-            return executor(onResolve, onReject, onCancel as OnCancel);
-        });
-    }
-
-     get [Symbol.toStringTag]() {
-            return "Cancellable Promise";
-     }
-
-    public then<TResult1 = T, TResult2 = never>(
-        onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
-        onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
-    ): Promise<TResult1 | TResult2> {
-        return this.#promise.then(onFulfilled, onRejected);
-    }
-
-    public catch<TResult = never>(
-        onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null
-    ): Promise<T | TResult> {
-        return this.#promise.catch(onRejected);
-    }
-
-    public finally(onFinally?: (() => void) | null): Promise<T> {
-        return this.#promise.finally(onFinally);
-    }
-
-    public cancel(): void {
-        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
-            return;
         }
-        this.#isCancelled = true;
+        this._isResolved = true
-        if (this.#cancelHandlers.length) {
+        if (this._resolve) this._resolve(value)
-            try {
+      }
-                for (const cancelHandler of this.#cancelHandlers) {
-                    cancelHandler();
-                }
-            } catch (error) {
-                console.warn('Cancellation threw an error', error);
-                return;
-            }
-        }
-        this.#cancelHandlers.length = 0;
-        this.#reject?.(new CancelError('Request aborted'));
-    }
 
-    public get isCancelled(): boolean {
+      const onReject = (reason?: unknown): void => {
-        return this.#isCancelled;
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return
+        }
+        this._isRejected = true
+        if (this._reject) this._reject(reason)
+      }
+
+      const onCancel = (cancelHandler: () => void): void => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return
+        }
+        this.cancelHandlers.push(cancelHandler)
+      }
+
+      Object.defineProperty(onCancel, "isResolved", {
+        get: (): boolean => this._isResolved,
+      })
+
+      Object.defineProperty(onCancel, "isRejected", {
+        get: (): boolean => this._isRejected,
+      })
+
+      Object.defineProperty(onCancel, "isCancelled", {
+        get: (): boolean => this._isCancelled,
+      })
+
+      return executor(onResolve, onReject, onCancel as OnCancel)
+    })
+  }
+
+  get [Symbol.toStringTag]() {
+    return "Cancellable Promise"
+  }
+
+  public then<TResult1 = T, TResult2 = never>(
+    onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+    onRejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,
+  ): Promise<TResult1 | TResult2> {
+    return this.promise.then(onFulfilled, onRejected)
+  }
+
+  public catch<TResult = never>(
+    onRejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null,
+  ): Promise<T | TResult> {
+    return this.promise.catch(onRejected)
+  }
+
+  public finally(onFinally?: (() => void) | null): Promise<T> {
+    return this.promise.finally(onFinally)
+  }
+
+  public cancel(): void {
+    if (this._isResolved || this._isRejected || this._isCancelled) {
+      return
     }
+    this._isCancelled = true
+    if (this.cancelHandlers.length) {
+      try {
+        for (const cancelHandler of this.cancelHandlers) {
+          cancelHandler()
+        }
+      } catch (error) {
+        console.warn("Cancellation threw an error", error)
+        return
+      }
+    }
+    this.cancelHandlers.length = 0
+    if (this._reject) this._reject(new CancelError("Request aborted"))
+  }
+
+  public get isCancelled(): boolean {
+    return this._isCancelled
+  }
 }

frontend/src/client/core/OpenAPI.ts

@@ -1,32 +1,57 @@
-/* generated using openapi-typescript-codegen -- do no edit */
+import type { AxiosRequestConfig, AxiosResponse } from "axios"
-/* istanbul ignore file */
+import type { ApiRequestOptions } from "./ApiRequestOptions"
-/* tslint:disable */
-/* eslint-disable */
-import type { ApiRequestOptions } from './ApiRequestOptions';
 
-type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>
-type Headers = Record<string, string>;
+type Middleware<T> = (value: T) => T | Promise<T>
+type Resolver<T> = (options: ApiRequestOptions<T>) => Promise<T>
+
+export class Interceptors<T> {
+  _fns: Middleware<T>[]
+
+  constructor() {
+    this._fns = []
+  }
+
+  eject(fn: Middleware<T>): void {
+    const index = this._fns.indexOf(fn)
+    if (index !== -1) {
+      this._fns = [...this._fns.slice(0, index), ...this._fns.slice(index + 1)]
+    }
+  }
+
+  use(fn: Middleware<T>): void {
+    this._fns = [...this._fns, fn]
+  }
+}
 
 export type OpenAPIConfig = {
-    BASE: string;
+  BASE: string
-    VERSION: string;
+  CREDENTIALS: "include" | "omit" | "same-origin"
-    WITH_CREDENTIALS: boolean;
+  ENCODE_PATH?: ((path: string) => string) | undefined
-    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+  HEADERS?: Headers | Resolver<Headers> | undefined
-    TOKEN?: string | Resolver<string> | undefined;
+  PASSWORD?: string | Resolver<string> | undefined
-    USERNAME?: string | Resolver<string> | undefined;
+  TOKEN?: string | Resolver<string> | undefined
-    PASSWORD?: string | Resolver<string> | undefined;
+  USERNAME?: string | Resolver<string> | undefined
-    HEADERS?: Headers | Resolver<Headers> | undefined;
+  VERSION: string
-    ENCODE_PATH?: ((path: string) => string) | undefined;
+  WITH_CREDENTIALS: boolean
-};
+  interceptors: {
+    request: Interceptors<AxiosRequestConfig>
+    response: Interceptors<AxiosResponse>
+  }
+}
 
 export const OpenAPI: OpenAPIConfig = {
-    BASE: '',
+  BASE: "",
-    VERSION: '0.1.0',
+  CREDENTIALS: "include",
-    WITH_CREDENTIALS: false,
+  ENCODE_PATH: undefined,
-    CREDENTIALS: 'include',
+  HEADERS: undefined,
-    TOKEN: undefined,
+  PASSWORD: undefined,
-    USERNAME: undefined,
+  TOKEN: undefined,
-    PASSWORD: undefined,
+  USERNAME: undefined,
-    HEADERS: undefined,
+  VERSION: "0.1.0",
-    ENCODE_PATH: undefined,
+  WITH_CREDENTIALS: false,
-};
+  interceptors: {
+    request: new Interceptors(),
+    response: new Interceptors(),
+  },
+}

frontend/src/client/core/request.ts

@@ -1,283 +1,325 @@
-/* generated using openapi-typescript-codegen -- do no edit */
+import axios from "axios"
-/* istanbul ignore file */
+import type {
-/* tslint:disable */
+  AxiosError,
-/* eslint-disable */
+  AxiosRequestConfig,
-import axios from 'axios';
+  AxiosResponse,
-import type { AxiosError, AxiosRequestConfig, AxiosResponse, AxiosInstance } from 'axios';
+  AxiosInstance,
-import FormData from 'form-data';
+} from "axios"
 
-import { ApiError } from './ApiError';
+import { ApiError } from "./ApiError"
-import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiRequestOptions } from "./ApiRequestOptions"
-import type { ApiResult } from './ApiResult';
+import type { ApiResult } from "./ApiResult"
-import { CancelablePromise } from './CancelablePromise';
+import { CancelablePromise } from "./CancelablePromise"
-import type { OnCancel } from './CancelablePromise';
+import type { OnCancel } from "./CancelablePromise"
-import type { OpenAPIConfig } from './OpenAPI';
+import type { OpenAPIConfig } from "./OpenAPI"
 
-export const isDefined = <T>(value: T | null | undefined): value is Exclude<T, null | undefined> => {
+export const isString = (value: unknown): value is string => {
-    return value !== undefined && value !== null;
+  return typeof value === "string"
-};
+}
 
-export const isString = (value: any): value is string => {
+export const isStringWithValue = (value: unknown): value is string => {
-    return typeof value === 'string';
+  return isString(value) && value !== ""
-};
+}
-
-export const isStringWithValue = (value: any): value is string => {
-    return isString(value) && value !== '';
-};
 
 export const isBlob = (value: any): value is Blob => {
-    return (
+  return value instanceof Blob
-        typeof value === 'object' &&
+}
-        typeof value.type === 'string' &&
-        typeof value.stream === 'function' &&
-        typeof value.arrayBuffer === 'function' &&
-        typeof value.constructor === 'function' &&
-        typeof value.constructor.name === 'string' &&
-        /^(Blob|File)$/.test(value.constructor.name) &&
-        /^(Blob|File)$/.test(value[Symbol.toStringTag])
-    );
-};
 
-export const isFormData = (value: any): value is FormData => {
+export const isFormData = (value: unknown): value is FormData => {
-    return value instanceof FormData;
+  return value instanceof FormData
-};
+}
 
 export const isSuccess = (status: number): boolean => {
-    return status >= 200 && status < 300;
+  return status >= 200 && status < 300
-};
+}
 
 export const base64 = (str: string): string => {
-    try {
+  try {
-        return btoa(str);
+    return btoa(str)
-    } catch (err) {
+  } catch (err) {
-        // @ts-ignore
+    // @ts-ignore
-        return Buffer.from(str).toString('base64');
+    return Buffer.from(str).toString("base64")
-    }
+  }
-};
+}
 
-export const getQueryString = (params: Record<string, any>): string => {
+export const getQueryString = (params: Record<string, unknown>): string => {
-    const qs: string[] = [];
+  const qs: string[] = []
 
-    const append = (key: string, value: any) => {
+  const append = (key: string, value: unknown) => {
-        qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`)
-    };
+  }
 
-    const process = (key: string, value: any) => {
+  const encodePair = (key: string, value: unknown) => {
-        if (isDefined(value)) {
+    if (value === undefined || value === null) {
-            if (Array.isArray(value)) {
+      return
-                value.forEach(v => {
-                    process(key, v);
-                });
-            } else if (typeof value === 'object') {
-                Object.entries(value).forEach(([k, v]) => {
-                    process(`${key}[${k}]`, v);
-                });
-            } else {
-                append(key, value);
-            }
-        }
-    };
-
-    Object.entries(params).forEach(([key, value]) => {
-        process(key, value);
-    });
-
-    if (qs.length > 0) {
-        return `?${qs.join('&')}`;
     }
 
-    return '';
+    if (value instanceof Date) {
-};
+      append(key, value.toISOString())
+    } else if (Array.isArray(value)) {
+      value.forEach((v) => encodePair(key, v))
+    } else if (typeof value === "object") {
+      Object.entries(value).forEach(([k, v]) => encodePair(`${key}[${k}]`, v))
+    } else {
+      append(key, value)
+    }
+  }
+
+  Object.entries(params).forEach(([key, value]) => encodePair(key, value))
+
+  return qs.length ? `?${qs.join("&")}` : ""
+}
 
 const getUrl = (config: OpenAPIConfig, options: ApiRequestOptions): string => {
-    const encoder = config.ENCODE_PATH || encodeURI;
+  const encoder = config.ENCODE_PATH || encodeURI
 
-    const path = options.url
+  const path = options.url
-        .replace('{api-version}', config.VERSION)
+    .replace("{api-version}", config.VERSION)
-        .replace(/{(.*?)}/g, (substring: string, group: string) => {
+    .replace(/{(.*?)}/g, (substring: string, group: string) => {
-            if (options.path?.hasOwnProperty(group)) {
+      if (options.path?.hasOwnProperty(group)) {
-                return encoder(String(options.path[group]));
+        return encoder(String(options.path[group]))
-            }
+      }
-            return substring;
+      return substring
-        });
-
-    const url = `${config.BASE}${path}`;
-    if (options.query) {
-        return `${url}${getQueryString(options.query)}`;
-    }
-    return url;
-};
-
-export const getFormData = (options: ApiRequestOptions): FormData | undefined => {
-    if (options.formData) {
-        const formData = new FormData();
-
-        const process = (key: string, value: any) => {
-            if (isString(value) || isBlob(value)) {
-                formData.append(key, value);
-            } else {
-                formData.append(key, JSON.stringify(value));
-            }
-        };
-
-        Object.entries(options.formData)
-            .filter(([_, value]) => isDefined(value))
-            .forEach(([key, value]) => {
-                if (Array.isArray(value)) {
-                    value.forEach(v => process(key, v));
-                } else {
-                    process(key, value);
-                }
-            });
-
-        return formData;
-    }
-    return undefined;
-};
-
-type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
-
-export const resolve = async <T>(options: ApiRequestOptions, resolver?: T | Resolver<T>): Promise<T | undefined> => {
-    if (typeof resolver === 'function') {
-        return (resolver as Resolver<T>)(options);
-    }
-    return resolver;
-};
-
-export const getHeaders = async (config: OpenAPIConfig, options: ApiRequestOptions, formData?: FormData): Promise<Record<string, string>> => {
-    const token = await resolve(options, config.TOKEN);
-    const username = await resolve(options, config.USERNAME);
-    const password = await resolve(options, config.PASSWORD);
-    const additionalHeaders = await resolve(options, config.HEADERS);
-    const formHeaders = typeof formData?.getHeaders === 'function' && formData?.getHeaders() || {}
-
-    const headers = Object.entries({
-        Accept: 'application/json',
-        ...additionalHeaders,
-        ...options.headers,
-        ...formHeaders,
     })
-    .filter(([_, value]) => isDefined(value))
+
-    .reduce((headers, [key, value]) => ({
+  const url = config.BASE + path
+  return options.query ? url + getQueryString(options.query) : url
+}
+
+export const getFormData = (
+  options: ApiRequestOptions,
+): FormData | undefined => {
+  if (options.formData) {
+    const formData = new FormData()
+
+    const process = (key: string, value: unknown) => {
+      if (isString(value) || isBlob(value)) {
+        formData.append(key, value)
+      } else {
+        formData.append(key, JSON.stringify(value))
+      }
+    }
+
+    Object.entries(options.formData)
+      .filter(([, value]) => value !== undefined && value !== null)
+      .forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          value.forEach((v) => process(key, v))
+        } else {
+          process(key, value)
+        }
+      })
+
+    return formData
+  }
+  return undefined
+}
+
+type Resolver<T> = (options: ApiRequestOptions<T>) => Promise<T>
+
+export const resolve = async <T>(
+  options: ApiRequestOptions<T>,
+  resolver?: T | Resolver<T>,
+): Promise<T | undefined> => {
+  if (typeof resolver === "function") {
+    return (resolver as Resolver<T>)(options)
+  }
+  return resolver
+}
+
+export const getHeaders = async <T>(
+  config: OpenAPIConfig,
+  options: ApiRequestOptions<T>,
+): Promise<Record<string, string>> => {
+  const [token, username, password, additionalHeaders] = await Promise.all([
+    // @ts-ignore
+    resolve(options, config.TOKEN),
+    // @ts-ignore
+    resolve(options, config.USERNAME),
+    // @ts-ignore
+    resolve(options, config.PASSWORD),
+    // @ts-ignore
+    resolve(options, config.HEADERS),
+  ])
+
+  const headers = Object.entries({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers,
+  })
+    .filter(([, value]) => value !== undefined && value !== null)
+    .reduce(
+      (headers, [key, value]) => ({
         ...headers,
         [key]: String(value),
-    }), {} as Record<string, string>);
+      }),
+      {} as Record<string, string>,
+    )
 
-    if (isStringWithValue(token)) {
+  if (isStringWithValue(token)) {
-        headers['Authorization'] = `Bearer ${token}`;
+    headers["Authorization"] = `Bearer ${token}`
+  }
+
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(`${username}:${password}`)
+    headers["Authorization"] = `Basic ${credentials}`
+  }
+
+  if (options.body !== undefined) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType
+    } else if (isBlob(options.body)) {
+      headers["Content-Type"] = options.body.type || "application/octet-stream"
+    } else if (isString(options.body)) {
+      headers["Content-Type"] = "text/plain"
+    } else if (!isFormData(options.body)) {
+      headers["Content-Type"] = "application/json"
     }
-
+  } else if (options.formData !== undefined) {
-    if (isStringWithValue(username) && isStringWithValue(password)) {
+    if (options.mediaType) {
-        const credentials = base64(`${username}:${password}`);
+      headers["Content-Type"] = options.mediaType
-        headers['Authorization'] = `Basic ${credentials}`;
     }
+  }
 
-    if (options.body) {
+  return headers
-        if (options.mediaType) {
+}
-            headers['Content-Type'] = options.mediaType;
-        } else if (isBlob(options.body)) {
-            headers['Content-Type'] = options.body.type || 'application/octet-stream';
-        } else if (isString(options.body)) {
-            headers['Content-Type'] = 'text/plain';
-        } else if (!isFormData(options.body)) {
-            headers['Content-Type'] = 'application/json';
-        }
-    }
 
-    return headers;
+export const getRequestBody = (options: ApiRequestOptions): unknown => {
-};
+  if (options.body) {
-
+    return options.body
-export const getRequestBody = (options: ApiRequestOptions): any => {
+  }
-    if (options.body) {
+  return undefined
-        return options.body;
+}
-    }
-    return undefined;
-};
 
 export const sendRequest = async <T>(
-    config: OpenAPIConfig,
+  config: OpenAPIConfig,
-    options: ApiRequestOptions,
+  options: ApiRequestOptions<T>,
-    url: string,
+  url: string,
-    body: any,
+  body: unknown,
-    formData: FormData | undefined,
+  formData: FormData | undefined,
-    headers: Record<string, string>,
+  headers: Record<string, string>,
-    onCancel: OnCancel,
+  onCancel: OnCancel,
-    axiosClient: AxiosInstance
+  axiosClient: AxiosInstance,
 ): Promise<AxiosResponse<T>> => {
-    const source = axios.CancelToken.source();
+  const controller = new AbortController()
 
-    const requestConfig: AxiosRequestConfig = {
+  let requestConfig: AxiosRequestConfig = {
-        url,
+    data: body ?? formData,
-        headers,
+    headers,
-        data: body ?? formData,
+    method: options.method,
-        method: options.method,
+    signal: controller.signal,
-        withCredentials: config.WITH_CREDENTIALS,
+    url,
-        cancelToken: source.token,
+    withCredentials: config.WITH_CREDENTIALS,
-    };
+  }
 
-    onCancel(() => source.cancel('The user aborted a request.'));
+  onCancel(() => controller.abort())
 
-    try {
+  for (const fn of config.interceptors.request._fns) {
-        return await axiosClient.request(requestConfig);
+    requestConfig = await fn(requestConfig)
-    } catch (error) {
+  }
-        const axiosError = error as AxiosError<T>;
+
-        if (axiosError.response) {
+  try {
-            return axiosError.response;
+    return await axiosClient.request(requestConfig)
-        }
+  } catch (error) {
-        throw error;
+    const axiosError = error as AxiosError<T>
+    if (axiosError.response) {
+      return axiosError.response
     }
-};
+    throw error
+  }
+}
 
-export const getResponseHeader = (response: AxiosResponse<any>, responseHeader?: string): string | undefined => {
+export const getResponseHeader = (
-    if (responseHeader) {
+  response: AxiosResponse<unknown>,
-        const content = response.headers[responseHeader];
+  responseHeader?: string,
-        if (isString(content)) {
+): string | undefined => {
-            return content;
+  if (responseHeader) {
-        }
+    const content = response.headers[responseHeader]
+    if (isString(content)) {
+      return content
     }
-    return undefined;
+  }
-};
+  return undefined
+}
 
-export const getResponseBody = (response: AxiosResponse<any>): any => {
+export const getResponseBody = (response: AxiosResponse<unknown>): unknown => {
-    if (response.status !== 204) {
+  if (response.status !== 204) {
-        return response.data;
+    return response.data
-    }
+  }
-    return undefined;
+  return undefined
-};
+}
 
-export const catchErrorCodes = (options: ApiRequestOptions, result: ApiResult): void => {
+export const catchErrorCodes = (
-    const errors: Record<number, string> = {
+  options: ApiRequestOptions,
-        400: 'Bad Request',
+  result: ApiResult,
-        401: 'Unauthorized',
+): void => {
-        403: 'Forbidden',
+  const errors: Record<number, string> = {
-        404: 'Not Found',
+    400: "Bad Request",
-        500: 'Internal Server Error',
+    401: "Unauthorized",
-        502: 'Bad Gateway',
+    402: "Payment Required",
-        503: 'Service Unavailable',
+    403: "Forbidden",
-        ...options.errors,
+    404: "Not Found",
-    }
+    405: "Method Not Allowed",
+    406: "Not Acceptable",
+    407: "Proxy Authentication Required",
+    408: "Request Timeout",
+    409: "Conflict",
+    410: "Gone",
+    411: "Length Required",
+    412: "Precondition Failed",
+    413: "Payload Too Large",
+    414: "URI Too Long",
+    415: "Unsupported Media Type",
+    416: "Range Not Satisfiable",
+    417: "Expectation Failed",
+    418: "Im a teapot",
+    421: "Misdirected Request",
+    422: "Unprocessable Content",
+    423: "Locked",
+    424: "Failed Dependency",
+    425: "Too Early",
+    426: "Upgrade Required",
+    428: "Precondition Required",
+    429: "Too Many Requests",
+    431: "Request Header Fields Too Large",
+    451: "Unavailable For Legal Reasons",
+    500: "Internal Server Error",
+    501: "Not Implemented",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout",
+    505: "HTTP Version Not Supported",
+    506: "Variant Also Negotiates",
+    507: "Insufficient Storage",
+    508: "Loop Detected",
+    510: "Not Extended",
+    511: "Network Authentication Required",
+    ...options.errors,
+  }
 
-    const error = errors[result.status];
+  const error = errors[result.status]
-    if (error) {
+  if (error) {
-        throw new ApiError(options, result, error);
+    throw new ApiError(options, result, error)
-    }
+  }
 
-    if (!result.ok) {
+  if (!result.ok) {
-        const errorStatus = result.status ?? 'unknown';
+    const errorStatus = result.status ?? "unknown"
-        const errorStatusText = result.statusText ?? 'unknown';
+    const errorStatusText = result.statusText ?? "unknown"
-        const errorBody = (() => {
+    const errorBody = (() => {
-            try {
+      try {
-                return JSON.stringify(result.body, null, 2);
+        return JSON.stringify(result.body, null, 2)
-            } catch (e) {
+      } catch (e) {
-                return undefined;
+        return undefined
-            }
+      }
-        })();
+    })()
 
-        throw new ApiError(options, result,
+    throw new ApiError(
-            `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`
+      options,
-        );
+      result,
-    }
+      `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`,
-};
+    )
+  }
+}
 
 /**
  * Request method
@@ -287,33 +329,59 @@ export const catchErrorCodes = (options: ApiRequestOptions, result: ApiResult):
  * @returns CancelablePromise<T>
  * @throws ApiError
  */
-export const request = <T>(config: OpenAPIConfig, options: ApiRequestOptions, axiosClient: AxiosInstance = axios): CancelablePromise<T> => {
+export const request = <T>(
-    return new CancelablePromise(async (resolve, reject, onCancel) => {
+  config: OpenAPIConfig,
-        try {
+  options: ApiRequestOptions<T>,
-            const url = getUrl(config, options);
+  axiosClient: AxiosInstance = axios,
-            const formData = getFormData(options);
+): CancelablePromise<T> => {
-            const body = getRequestBody(options);
+  return new CancelablePromise(async (resolve, reject, onCancel) => {
-            const headers = await getHeaders(config, options, formData);
+    try {
+      const url = getUrl(config, options)
+      const formData = getFormData(options)
+      const body = getRequestBody(options)
+      const headers = await getHeaders(config, options)
 
-            if (!onCancel.isCancelled) {
+      if (!onCancel.isCancelled) {
-                const response = await sendRequest<T>(config, options, url, body, formData, headers, onCancel, axiosClient);
+        let response = await sendRequest<T>(
-                const responseBody = getResponseBody(response);
+          config,
-                const responseHeader = getResponseHeader(response, options.responseHeader);
+          options,
+          url,
+          body,
+          formData,
+          headers,
+          onCancel,
+          axiosClient,
+        )
 
-                const result: ApiResult = {
+        for (const fn of config.interceptors.response._fns) {
-                    url,
+          response = await fn(response)
-                    ok: isSuccess(response.status),
-                    status: response.status,
-                    statusText: response.statusText,
-                    body: responseHeader ?? responseBody,
-                };
-
-                catchErrorCodes(options, result);
-
-                resolve(result.body);
-            }
-        } catch (error) {
-            reject(error);
         }
-    });
+
-};
+        const responseBody = getResponseBody(response)
+        const responseHeader = getResponseHeader(
+          response,
+          options.responseHeader,
+        )
+
+        let transformedBody = responseBody
+        if (options.responseTransformer && isSuccess(response.status)) {
+          transformedBody = await options.responseTransformer(responseBody)
+        }
+
+        const result: ApiResult = {
+          url,
+          ok: isSuccess(response.status),
+          status: response.status,
+          statusText: response.statusText,
+          body: responseHeader ?? transformedBody,
+        }
+
+        catchErrorCodes(options, result)
+
+        resolve(result.body)
+      }
+    } catch (error) {
+      reject(error)
+    }
+  })
+}

frontend/src/client/index.ts

@@ -1,49 +1,6 @@
-/* generated using openapi-typescript-codegen -- do no edit */
+// This file is auto-generated by @hey-api/openapi-ts
-/* istanbul ignore file */
+export { ApiError } from "./core/ApiError"
-/* tslint:disable */
+export { CancelablePromise, CancelError } from "./core/CancelablePromise"
-/* eslint-disable */
+export { OpenAPI, type OpenAPIConfig } from "./core/OpenAPI"
-export { ApiError } from './core/ApiError';
+export * from "./sdk.gen"
-export { CancelablePromise, CancelError } from './core/CancelablePromise';
+export * from "./types.gen"
-export { OpenAPI } from './core/OpenAPI';
-export type { OpenAPIConfig } from './core/OpenAPI';
-
-export type { Body_login_login_access_token } from './models/Body_login_login_access_token';
-export type { HTTPValidationError } from './models/HTTPValidationError';
-export type { ItemCreate } from './models/ItemCreate';
-export type { ItemOut } from './models/ItemOut';
-export type { ItemsOut } from './models/ItemsOut';
-export type { ItemUpdate } from './models/ItemUpdate';
-export type { Message } from './models/Message';
-export type { NewPassword } from './models/NewPassword';
-export type { Token } from './models/Token';
-export type { UpdatePassword } from './models/UpdatePassword';
-export type { UserCreate } from './models/UserCreate';
-export type { UserCreateOpen } from './models/UserCreateOpen';
-export type { UserOut } from './models/UserOut';
-export type { UsersOut } from './models/UsersOut';
-export type { UserUpdate } from './models/UserUpdate';
-export type { UserUpdateMe } from './models/UserUpdateMe';
-export type { ValidationError } from './models/ValidationError';
-
-export { $Body_login_login_access_token } from './schemas/$Body_login_login_access_token';
-export { $HTTPValidationError } from './schemas/$HTTPValidationError';
-export { $ItemCreate } from './schemas/$ItemCreate';
-export { $ItemOut } from './schemas/$ItemOut';
-export { $ItemsOut } from './schemas/$ItemsOut';
-export { $ItemUpdate } from './schemas/$ItemUpdate';
-export { $Message } from './schemas/$Message';
-export { $NewPassword } from './schemas/$NewPassword';
-export { $Token } from './schemas/$Token';
-export { $UpdatePassword } from './schemas/$UpdatePassword';
-export { $UserCreate } from './schemas/$UserCreate';
-export { $UserCreateOpen } from './schemas/$UserCreateOpen';
-export { $UserOut } from './schemas/$UserOut';
-export { $UsersOut } from './schemas/$UsersOut';
-export { $UserUpdate } from './schemas/$UserUpdate';
-export { $UserUpdateMe } from './schemas/$UserUpdateMe';
-export { $ValidationError } from './schemas/$ValidationError';
-
-export { ItemsService } from './services/ItemsService';
-export { LoginService } from './services/LoginService';
-export { UsersService } from './services/UsersService';
-export { UtilsService } from './services/UtilsService';

frontend/src/client/models/Body_login_login_access_token.ts

@@ -1,13 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-export type Body_login_login_access_token = {
-    grant_type?: (string | null);
-    username: string;
-    password: string;
-    scope?: string;
-    client_id?: (string | null);
-    client_secret?: (string | null);
-};

frontend/src/client/models/HTTPValidationError.ts

@@ -1,10 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-import type { ValidationError } from './ValidationError';
-
-export type HTTPValidationError = {
-    detail?: Array<ValidationError>;
-};

frontend/src/client/models/ItemCreate.ts

@@ -1,9 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-export type ItemCreate = {
-    title: string;
-    description?: (string | null);
-};

frontend/src/client/models/ItemOut.ts

@@ -1,11 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-export type ItemOut = {
-    title: string;
-    description?: (string | null);
-    id: number;
-    owner_id: number;
-};

frontend/src/client/models/ItemUpdate.ts

@@ -1,9 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-export type ItemUpdate = {
-    title?: (string | null);
-    description?: (string | null);
-};

frontend/src/client/models/ItemsOut.ts

@@ -1,11 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-import type { ItemOut } from './ItemOut';
-
-export type ItemsOut = {
-    data: Array<ItemOut>;
-    count: number;
-};

frontend/src/client/models/Message.ts

@@ -1,8 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-export type Message = {
-    message: string;
-};

frontend/src/client/models/NewPassword.ts

@@ -1,9 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-export type NewPassword = {
-    token: string;
-    new_password: string;
-};