chore: bump version (v0.19.1) (#679)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

.editorconfig

@@ -0,0 +1,10 @@
+[*]
+charset = utf-8
+insert_final_newline = true
+end_of_line = lf
+indent_style = space
+indent_size = 2
+max_line_length = 80
+
+[*.rs]
+indent_size = 4

.eslintrc

@@ -1,103 +0,0 @@
-{
-  "root": true,
-  "reportUnusedDisableDirectives": true,
-  "ignorePatterns": ["**/build", "**/dist"],
-  "parser": "@typescript-eslint/parser",
-  "plugins": ["@typescript-eslint", "import"],
-  "extends": [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended",
-    "plugin:@typescript-eslint/stylistic",
-    "plugin:import/recommended",
-    "plugin:import/typescript",
-    "prettier",
-  ],
-  "env": {
-    "browser": true,
-    "es2020": true,
-  },
-  "parserOptions": {
-    "tsconfigRootDir": ".",
-    "project": true,
-    "sourceType": "module",
-    "ecmaVersion": 2020,
-  },
-  "settings": {
-    "import/parsers": {
-      "@typescript-eslint/parser": [".ts", ".tsx"],
-    },
-    "import/resolver": {
-      "typescript": true,
-    },
-    "react": {
-      "version": "detect",
-    },
-  },
-  "rules": {
-    "@typescript-eslint/array-type": "error",
-    "@typescript-eslint/ban-types": "error",
-    "@typescript-eslint/ban-ts-comment": "error",
-    "@typescript-eslint/consistent-type-definitions": "error",
-    "@typescript-eslint/consistent-type-imports": [
-      "error",
-      { "prefer": "type-imports" },
-    ],
-    "@typescript-eslint/explicit-module-boundary-types": "error",
-    "@typescript-eslint/method-signature-style": ["error", "property"],
-    "@typescript-eslint/naming-convention": [
-      "error",
-      {
-		"selector": "typeParameter",
-        "format": ["PascalCase"],
-        "leadingUnderscore": "forbid",
-        "trailingUnderscore": "forbid",
-        "custom": {
-          "regex": "^(T|T[A-Z][A-Za-z]+)$",
-          "match": true,
-        },
-      },
-    ],
-    "@typescript-eslint/no-empty-function": "error",
-    "@typescript-eslint/no-empty-interface": "error",
-    "@typescript-eslint/no-explicit-any": "off",
-    "@typescript-eslint/no-non-null-assertion": "error",
-    "@typescript-eslint/no-unnecessary-condition": "error",
-    "@typescript-eslint/no-unnecessary-type-assertion": "error",
-    "@typescript-eslint/no-unused-vars": "error",
-    "@typescript-eslint/explicit-function-return-type": "error",
-    "@typescript-eslint/no-inferrable-types": [
-      "error",
-      { "ignoreParameters": true },
-    ],
-    "import/default": "error",
-    "import/export": "error",
-    "import/namespace": "error",
-    "import/newline-after-import": "error",
-    "import/no-cycle": "error",
-    "import/no-duplicates": "off",
-    "import/no-named-as-default-member": "error",
-    "import/no-unused-modules": "error",
-    "import/order": [
-      "off",
-      {
-        "groups": [
-          "builtin",
-          "external",
-          "internal",
-          "parent",
-          "sibling",
-          "index",
-          "object",
-          "type",
-        ],
-      },
-    ],
-    "no-case-declarations": "error",
-    "no-empty": "error",
-    "no-prototype-builtins": "error",
-    "no-redeclare": "error",
-    "no-shadow": "error",
-    "no-undef": "off",
-    "sort-imports": "off",
-  },
-}

.gitattributes

@@ -1 +1,10 @@
 examples/** linguist-documentation
+*.css linguist-detectable=false
+*.scss linguist-detectable=false
+*.js linguist-detectable=false
+*.jsx linguist-detectable=true
+*.tsx linguist-detectable=true
+*.ts linguist-detectable=true
+*.rs linguist-detectable=true 
+*.html linguist-detectable=false  
+*.sh linguist-detectable=false

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,60 @@
+name: Bug report
+description: File a bug report
+title: '[Bug]: '
+type: Bug
+labels: ['bug']
+
+body:
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: A clear and concise description of what the bug is.
+    validations:
+      required: true
+  - type: textarea
+    id: expected-behaviour
+    attributes:
+      label: Expected behaviour
+      description: A clear and concise description of what you expected to happen.
+    validations:
+      required: true
+  - type: textarea
+    id: steps
+    attributes:
+      label: How to reproduce
+      description: Steps to reproduce the behavior (code, example repository)
+    validations:
+      required: true
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots
+      description: If applicable, add screenshots to help explain your problem.
+    validations:
+      required: false
+  - type: textarea
+    id: system-info
+    attributes:
+      label: System Info
+      description: Output of `npx envinfo --system --npmPackages 'tuono' --binaries --browsers`
+      render: shell
+      placeholder: System, Binaries, Browsers
+    validations:
+      required: true
+  - type: textarea
+    id: system-info-rust
+    attributes:
+      label: System info (Rust)
+      description: Output of `rustc --version && cargo --version && tuono --version`
+      render: shell
+      placeholder: 'rustc, cargo and tuono binary version'
+    validations:
+      required: true
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional context
+      description: Add any other context about the bug here.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Ask a question / Get support
+    url: https://discord.com/invite/khQzPa654B
+    about: Ask questions and discuss with other community members

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,36 @@
+name: Feature request
+description: Suggest an idea for this project
+title: '[Feature request]: '
+type: Feature
+labels: ['enhancement']
+
+body:
+  - type: textarea
+    id: description
+    attributes:
+      label: Is your feature request related to a problem? Please describe.
+      description: A clear and concise description of what the problem is.
+      placeholder: I'm always frustrated when [...]
+    validations:
+      required: true
+  - type: textarea
+    id: solution
+    attributes:
+      label: Describe the solution you'd like
+      description: A clear and concise description of what you want to happen.
+    validations:
+      required: true
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: Describe alternatives you've considered
+      description: A clear and concise description of any alternative solutions or features you've considered.
+    validations:
+      required: false
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional context
+      description: Add any other context or screenshots about the feature request here.
+    validations:
+      required: false

.github/actions/install-node-dependencies/action.yml

@@ -0,0 +1,37 @@
+name: Install NodeJS Dependencies
+description: This is a composite GitHub Action that sets up pnpm, node and installs the project's dependencies.
+
+inputs:
+  node-version:
+    description: 'Explicit node version. Otherwise fallback reading `.nvmrc`. Use in conjunction with matrix'
+    required: false
+  registry-url:
+    description: 'https://github.com/actions/setup-node?tab=readme-ov-file#usage'
+    required: false
+    default: ''
+
+runs:
+  using: composite
+  steps:
+    - name: Install pnpm
+      uses: pnpm/action-setup@v4
+
+    - name: Setup Node.js (via input)
+      if: ${{ inputs.node-version }}
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ inputs.node-version }}
+        registry-url: ${{ inputs.registry-url }}
+        cache: 'pnpm'
+
+    - name: Setup Node.js (via .nvmrc)
+      if: ${{ !inputs.node-version }}
+      uses: actions/setup-node@v4
+      with:
+        node-version-file: '.nvmrc'
+        registry-url: ${{ inputs.registry-url }}
+        cache: 'pnpm'
+
+    - name: Install Dependencies
+      shell: bash
+      run: pnpm install --frozen-lockfile

.github/labeler.yml

@@ -0,0 +1,34 @@
+# @see https://github.com/actions/labeler
+
+rust:
+  - changed-files:
+      - any-glob-to-any-file: ['crates/**', 'Cargo.toml']
+
+typescript:
+  - changed-files:
+      - any-glob-to-any-file:
+          [
+            'devtools/**',
+            'packages/**',
+            'package.json',
+            'pnpm-*.yaml',
+            'eslint.config.js',
+            'tsconfig.json',
+          ]
+
+'CI/CD':
+  - changed-files:
+      - any-glob-to-any-file: ['.github/**']
+
+'repo maintenance':
+  - changed-files:
+      - any-glob-to-any-file:
+          [
+            'devtools/**',
+            '.npmrc',
+            '.nvmrc',
+            '.prettierrc',
+            '.prettierignore',
+            'renovate.json',
+            'turbo.json',
+          ]

.github/pull_request_template.md

@@ -0,0 +1,24 @@
+<!--
+👋 Thank you for your Pull Request 🙏
+-->
+
+### Checklist
+
+- [ ] I have read [Contributing > Pull requests](https://tuono.dev/documentation/contributing/pull-requests)
+
+### Related issue
+
+Fixes #0
+
+<!-- Replace the content with "None" if you haven't an issue to link -->
+
+### Overview
+
+<!--
+
+Explain the context and why you're making that change.
+What is the problem you're trying to solve?
+If a new feature is being added,
+describe the intended use case that feature fulfills.
+
+-->

.github/workflows/docker-ci.yml

@@ -0,0 +1,61 @@
+name: Docker CI
+
+# If we need support more OS refer to
+# https://github.com/tuono-labs/tuono/pull/332#issuecomment-2614439692
+
+on:
+  push:
+    branches:
+      - 'main'
+  pull_request:
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.head_ref || github.ref }}'
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  build_and_test:
+    name: Build and Test Docker Image on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 15
+
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Build and Run Docker Compose
+        run: |
+          docker compose -f docker/compose.yml up --build -d
+
+      - name: Check if the container is running
+        run: |
+          docker ps --filter "name=tuono-source-container" --format "table {{.Names}}\t{{.Status}}"
+          if ! docker ps --filter "name=tuono-source-container" --format "{{.Status}}" | grep -q "Up"; then
+            echo "Error: Container 'tuono-source-container' is not running."
+            exit 1
+          fi
+
+      - name: Check commands inside container
+        run: |
+          docker exec tuono-source-container pnpm --version || { echo "Error: pnpm is not available."; exit 1; }
+          docker exec tuono-source-container tuono --version || { echo "Error: tuono is not available."; exit 1; }
+
+      - name: Run cargo test
+        run: docker exec tuono-source-container cargo test
+
+      - name: Install node dependencies in each tuono's sub-projets
+        run: docker exec tuono-source-container bash -c 'for dir in /tuono/packages/*; do [ -d "$dir" ] && (cd "$dir" && yes | pnpm install --frozen-lockfile); done'
+
+      - name: Run pnpm test
+        run: docker exec tuono-source-container pnpm test
+
+      - name: Tear Down Docker Compose
+        if: always()
+        run: |
+          docker compose -f docker/compose.yml down --volumes

.github/workflows/e2e-ci.yml

@@ -0,0 +1,61 @@
+name: E2E CI
+
+on:
+  push:
+    branches:
+      - 'main'
+  pull_request:
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.head_ref || github.ref }}'
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  e2e:
+    name: E2E Test (${{ matrix.os }})
+
+    strategy:
+      fail-fast: true
+      matrix:
+        os:
+          - 'ubuntu-latest'
+          - 'macos-latest'
+          - 'windows-latest'
+
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 15
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install NodeJS Dependencies
+        uses: ./.github/actions/install-node-dependencies
+
+      - name: Setup rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+
+      - name: Install Playwright Browsers
+        run: pnpm exec playwright install
+
+      - name: Run Playwright E2E tests
+        run: pnpm test:e2e
+
+  ci_ok:
+    name: E2E CI OK
+    runs-on: ubuntu-latest
+    timeout-minutes: 1
+    if: always()
+    needs: [e2e]
+    env:
+      FAILURE: ${{ contains(join(needs.*.result, ','), 'failure') }}
+      CANCELLED: ${{ contains(join(needs.*.result, ','), 'cancelled') }}
+    steps:
+      - name: Check for failure or cancelled jobs result
+        shell: bash
+        run: |
+          echo "Failure: $FAILURE - Cancelled: $CANCELLED"
+          if [ "$FAILURE" = "false" ] && [ "$CANCELLED" = "false" ]; then
+            exit 0
+          else
+            exit 1
+          fi

.github/workflows/examples-ci.yml

@@ -0,0 +1,123 @@
+name: Examples CI
+
+on:
+  push:
+    branches:
+      - 'main'
+  pull_request:
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.head_ref || github.ref }}'
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  example_list:
+    name: Get examples names
+    runs-on: ubuntu-latest
+    timeout-minutes: 1
+
+    outputs:
+      names: ${{ steps.find_folder.outputs.names }}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - id: find_folder
+        working-directory: examples
+        # produces the list of folder inside examples without leading `./` and trailing `/`:
+        # ```text
+        # tuono-tutorial
+        # with-tailwind
+        # tuono-app
+        # with-mdx
+        # ```
+        #
+        # after, using `jq` the output is converted into a JSON array:
+        # ```json
+        # ["tuono-tutorial","with-tailwind","tuono-app","with-mdx"]
+        # ```
+        #
+        # and added to `$GITHUB_OUTPUT` env variable:
+        run: |
+          NAMES=$(find . -mindepth 1 -maxdepth 1 -type d -exec basename {} \;)
+          echo "names=$(echo "$NAMES" | jq -R -s -c 'split("\n")[:-1]')" >> "$GITHUB_OUTPUT"
+
+  check_rust:
+    needs:
+      - example_list
+
+    strategy:
+      matrix:
+        example_name: ${{ fromJson(needs.example_list.outputs.names) }}
+        os:
+          - 'ubuntu-latest'
+          - 'macos-latest'
+          # to be added
+          # - 'windows-latest'
+
+        # Only on this repo some examples build including plugins fails
+        # However, if the project is downloaded via `tuono new`` it will work
+        # @see https://github.com/tuono-labs/tuono/pull/605#pullrequestreview-2656262230
+        # needs further investigations
+        exclude:
+          - example_name: with-tailwind
+
+    name: 'Check `${{ matrix.example_name }}` build on ${{ matrix.os }}'
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 15
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install NodeJS Dependencies
+        uses: ./.github/actions/install-node-dependencies
+
+      - name: Setup rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+
+      - name: Build Rust
+        run: cargo build
+
+      - name: Build typescript
+        run: pnpm run build
+
+      - name: Check "build"
+        working-directory: ./examples/${{ matrix.example_name }}
+        run: ../../target/debug/tuono build
+
+  check_typescript:
+    name: Check typescript
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install NodeJS Dependencies
+        uses: ./.github/actions/install-node-dependencies
+
+      - name: Build typescript
+        run: pnpm run build
+
+      - name: Check formatting
+        run: pnpm run examples:format
+
+      - name: Typecheck
+        run: pnpm run examples:typecheck
+
+  ci_ok:
+    name: Examples CI OK
+    runs-on: ubuntu-latest
+    timeout-minutes: 1
+    if: always()
+    needs:
+      - example_list
+      - check_rust
+      - check_typescript
+    steps:
+      - name: Exit with error if some jobs are not successful
+        run: exit 1
+        if: ${{ always() && (contains(needs.*.result, 'failure') || contains(needs.*.result, 'skipped') || contains(needs.*.result, 'cancelled')) }}

.github/workflows/pr-labeler.yml

@@ -0,0 +1,27 @@
+name: 'PR Labeler'
+
+# @see https://github.com/actions/labeler
+# @see .github/labeler.yml
+
+on:
+  - pull_request_target
+
+jobs:
+  labeler:
+    name: 'Manage labels'
+
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: read
+      pull-requests: write
+
+    steps:
+      # Add checkout step to load labeler.yml locally,
+      # rather than from an API request
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - uses: actions/labeler@v5
+        with:
+          sync-labels: true

.github/workflows/pr-title-checker.yml

@@ -0,0 +1,61 @@
+name: 'PR Title Checker'
+
+# This workflow ensures that PR titles adhere to a pattern
+# similar to conventional commits standard
+
+on:
+  pull_request:
+    types:
+      - opened
+      - edited
+      - synchronize
+      - labeled
+      - unlabeled
+
+env:
+  PR_TITLE: ${{ github.event.pull_request.title }}
+
+jobs:
+  check_pr_title:
+    name: 'PR Title Checker'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check type
+        id: type
+        # @warning Keep in sync with https://github.com/tuono-labs/tuono-documentation/blob/main/src/routes/documentation/contributing/pull-requests.mdx
+        run: |
+          VALID_COMMIT_TYPES="chore|ci|docs|feat|fix|refactor|test"
+          REGEX="^(${VALID_COMMIT_TYPES})(\(.*\))?!?: .*"
+
+          if ! [[ $PR_TITLE =~ $REGEX ]]; then
+            echo "::error title=Type::The title has an incorrect type. Valid types are ${VALID_COMMIT_TYPES}"
+            echo "result=fail" >> "$GITHUB_OUTPUT"
+          else
+            echo "::notice title=Type::The title is using a valid type"
+            echo "result=ok" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Check length
+        id: length
+        run: |
+          MAX_LENGTH=100
+          LENGTH=${#PR_TITLE}
+
+          if [ $LENGTH -gt $MAX_LENGTH ]; then
+            echo "::error title=Length::The title is longer than $MAX_LENGTH characters"
+            echo "result=fail" >> "$GITHUB_OUTPUT"
+          else
+            echo "::notice title=Length::The title length is within the maximum value of $MAX_LENGTH characters"
+            echo "result=ok" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Check result
+        env:
+          FAILURE: ${{ contains(join(steps.*.outputs.result, ','), 'fail') }}
+        run: |
+          echo "Failure: $FAILURE"
+          if [ "$FAILURE" = "false" ]; then
+            exit 0
+          else
+            exit 1
+          fi

.github/workflows/release.yml

@@ -1,78 +1,68 @@
 name: Publish on npm and crates
+
 on:
   release:
     types: [published]
 
 jobs:
-  publish-on-npm-dry-run:
+  publish_npm_dry_run:
+    name: NPM publish (dry run)
     runs-on: ubuntu-latest
+
     steps:
-      - name: Checkout
+      - name: Checkout code
         uses: actions/checkout@v4
 
-      - name: Install Node.js
-        uses: actions/setup-node@v4
+      - name: Install NodeJS Dependencies
+        uses: ./.github/actions/install-node-dependencies
         with:
-          node-version: 20
           registry-url: 'https://registry.npmjs.org'
 
-      - uses: pnpm/action-setup@v3
-        name: Install pnpm
-        with:
-          version: 8
-          run_install: false
-
-      - name: Install dependencies
-        run: pnpm install 
-
       - name: Build
         run: pnpm build
 
       - name: Publish
-        run: pnpm publish -r --no-git-checks --dry-run 
+        run: pnpm publish -r --no-git-checks --dry-run
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
 
-  publish-on-crates-dry-run:
+  publish_crates_dry_run:
+    name: Crates publish (dry run)
     runs-on: ubuntu-latest
+
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions-rs/toolchain@v1
-      with:
-          toolchain: stable
-          override: true
-    - uses: katyo/publish-crates@v2
-      with:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: 'stable'
+
+      - uses: katyo/publish-crates@v2
+        with:
           path: './crates/tuono'
           dry-run: true
           registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}
           check-repo: true
 
-  publish-on-npm:
-    needs: [publish-on-crates-dry-run, publish-on-npm-dry-run]
+  publish_npm:
+    name: NPM publish
+    needs: [publish_npm_dry_run, publish_crates_dry_run]
     runs-on: ubuntu-latest
+
     steps:
-      - name: Checkout
+      - name: Checkout code
         uses: actions/checkout@v4
 
-      - name: Install Node.js
-        uses: actions/setup-node@v4
+      - name: Install NodeJS Dependencies
+        uses: ./.github/actions/install-node-dependencies
         with:
-          node-version: 20
           registry-url: 'https://registry.npmjs.org'
 
-      - uses: pnpm/action-setup@v3
-        name: Install pnpm
-        with:
-          version: 8
-          run_install: false
-
       - name: Clone root README.md on tuono package
         run: cp README.md packages/tuono/README.md
 
-      - name: Install dependencies
-        run: pnpm install 
-
       - name: Build
         run: pnpm build
 
@@ -81,17 +71,22 @@ jobs:
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
 
-  publish-on-crates:
-    needs: [publish-on-crates-dry-run, publish-on-npm-dry-run]
+  publish_crates:
+    name: Crates publish
+    needs: [publish_npm_dry_run, publish_crates_dry_run]
     runs-on: ubuntu-latest
+
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions-rs/toolchain@v1
-      with:
-          toolchain: stable
-          override: true
-    - uses: katyo/publish-crates@v2
-      with:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: 'stable'
+
+      - uses: katyo/publish-crates@v2
+        with:
           path: './crates/tuono'
           registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}
           check-repo: true

.github/workflows/repo-root-ci.yml

@@ -0,0 +1,51 @@
+name: Repo root CI
+
+# All workflows are triggered based on specific paths,
+# the root repository is something that is not applicable to rust nor typescript
+# so it has been moved in a standalone workflow
+
+on:
+  push:
+    branches:
+      - 'main'
+  pull_request:
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.head_ref || github.ref }}'
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  format:
+    name: Check format
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install NodeJS Dependencies
+        uses: ./.github/actions/install-node-dependencies
+
+      - name: Test project
+        run: pnpm repo:root:format
+
+  ci_ok:
+    name: Repo root CI OK
+    runs-on: ubuntu-latest
+    timeout-minutes: 1
+    if: always()
+    needs: [format]
+    env:
+      FAILURE: ${{ contains(join(needs.*.result, ','), 'failure') }}
+      CANCELLED: ${{ contains(join(needs.*.result, ','), 'cancelled') }}
+    steps:
+      - name: Check for failure or cancelled jobs result
+        shell: bash
+        run: |
+          echo "Failure: $FAILURE - Cancelled: $CANCELLED"
+          if [ "$FAILURE" = "false" ] && [ "$CANCELLED" = "false" ]; then
+            exit 0
+          else
+            exit 1
+          fi

.github/workflows/rust-ci.yml

@@ -0,0 +1,86 @@
+name: Rust CI
+
+on:
+  push:
+    branches:
+      - 'main'
+  pull_request:
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.head_ref || github.ref }}'
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build_and_test:
+    name: Build and test crates on ${{ matrix.os }} with rust ${{ matrix.toolchain }}
+
+    strategy:
+      fail-fast: true
+      matrix:
+        os:
+          - 'ubuntu-latest'
+          - 'macos-latest'
+          - 'windows-latest'
+        toolchain:
+          - 'stable'
+
+        # Test `beta` and `nightly` toolchains only on `ubuntu`
+        # https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/running-variations-of-jobs-in-a-workflow#expanding-or-adding-matrix-configurations
+        include:
+          - toolchain: 'beta'
+            os: 'ubuntu-latest'
+          - toolchain: 'nightly'
+            os: 'ubuntu-latest'
+
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 15
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: ${{ matrix.toolchain }}
+
+      - run: cargo build --verbose
+      - run: cargo test --verbose
+
+  lint_and_fmt:
+    name: Check format and lint rust crates
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+
+      - run: cargo fmt --all -- --check
+      - run: cargo clippy -- -D warnings
+
+  ci_ok:
+    name: Rust CI OK
+    runs-on: ubuntu-latest
+    timeout-minutes: 1
+    if: always()
+    needs: [build_and_test, lint_and_fmt]
+    env:
+      FAILURE: ${{ contains(join(needs.*.result, ','), 'failure') }}
+      CANCELLED: ${{ contains(join(needs.*.result, ','), 'cancelled') }}
+    steps:
+      - name: Check for failure or cancelled jobs result
+        shell: bash
+        run: |
+          echo "Failure: $FAILURE - Cancelled: $CANCELLED"
+          if [ "$FAILURE" = "false" ] && [ "$CANCELLED" = "false" ]; then
+            exit 0
+          else
+            exit 1
+          fi

.github/workflows/rust.yml

@@ -1,40 +0,0 @@
-name: Rust CI
-
-on:
-  push:
-    paths:
-      - '.github/**'
-      - 'crates/**'
-  pull_request:
-    paths:
-      - '.github/**'
-      - 'crates/**'
-
-env: 
-  CARGO_TERM_COLOR: always
-
-jobs:
-  lint_and_fmt:
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-      - run: cargo fmt --all -- --check
-      - run: cargo clippy -- -D warnings
-
-  build_and_test:
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
-    name: Build and test rust crates
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        toolchain:
-          - stable
-          - beta
-          - nightly
-    steps:
-      - uses: actions/checkout@v4
-      - run: rustup update ${{ matrix.toolchain }} && rustup default ${{ matrix.toolchain }}
-      - run: cargo build --verbose
-      - run: cargo test --verbose

.github/workflows/spell-checking.yml

@@ -0,0 +1,70 @@
+name: Spell Checker
+
+on:
+  push:
+    branches:
+      - 'main'
+
+  pull_request:
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.head_ref || github.ref }}'
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  spell_checking:
+    name: LanguageTool
+    runs-on: ubuntu-latest
+
+    permissions:
+      checks: write
+      contents: read
+      pull-requests: write
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          # Keep this value in order to show the error comments
+          # also on edited files.
+          fetch-depth: 2
+
+      # If the workflow is triggered by a push use check reporter
+      #
+      # If the workflow is triggered by a PR coming from the
+      # same repository, the author has write access so we can
+      # use pr-review reporter since the GITHUB_TOKEN will have review
+      # write permissions
+      #
+      # Otherwise use annotation reporter that do not require any
+      # particular permission
+      #
+      # Why this?
+      # https://github.com/Valerioageno/tuono/pull/137#pullrequestreview-2455455272
+      - name: Set reporter
+        id: reporter
+        env:
+          EVENT_NAME: ${{ github.event_name }}
+          FROM_MAIN_REPO: ${{ github.event.pull_request.head.repo.full_name == github.event.pull_request.base.repo.full_name }}
+        run: |
+          echo "EVENT_NAME: $EVENT_NAME FROM_MAIN_REPO: $FROM_MAIN_REPO"
+          if [ "$EVENT_NAME" == 'push' ]; then
+            echo "name=github-check" >> $GITHUB_OUTPUT
+          elif [ "$FROM_MAIN_REPO" == 'true' ]; then
+            echo "name=github-pr-review" >> $GITHUB_OUTPUT
+          else
+            echo "name=github-pr-annotations" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Review dog languagetool
+        uses: reviewdog/action-languagetool@v1
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          # Change reviewdog reporter if you need [github-pr-check,github-check,github-pr-review].
+          reporter: ${{ steps.reporter.outputs.name }}
+          # Change reporter level if you need.
+          level: 'warning'
+          patterns: '**/*.md **/*.txt **/*.mdx'
+          # enabled_categories: "STYLE,PLAIN_ENGLISH,WHITESPACE_RULE,EN_QUOTES,DASH_RULE,WORD_CONTAINS_UNDERSCORE,UPPERCASE_SENTENCE_START,ARROWS,COMMA_PARENTHESIS_WHITESPACE,UNLIKELY_OPENING_PUNCTUATION,SENTENCE_WHITESPACE,EN_UNPAIRED_BRACKETS,PHRASE_REPETITION,PUNCTUATION_PARAGRAPH_END"
+          disabled_categories: ''
+          disabled_rules: ''

.github/workflows/typescript-ci.yml

@@ -0,0 +1,80 @@
+name: Typescript CI
+
+on:
+  push:
+    branches:
+      - 'main'
+  pull_request:
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.head_ref || github.ref }}'
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  build_and_test:
+    name: Check build and test
+
+    strategy:
+      fail-fast: true
+      matrix:
+        os:
+          - 'ubuntu-latest'
+          - 'macos-latest'
+          - 'windows-latest'
+
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 15
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install NodeJS Dependencies
+        uses: ./.github/actions/install-node-dependencies
+
+      - name: Build project
+        run: pnpm build
+
+      - name: Test project
+        run: pnpm test
+
+  lint_and_fmt:
+    name: Check format and lint
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install NodeJS Dependencies
+        uses: ./.github/actions/install-node-dependencies
+
+      - name: Check formatting
+        run: pnpm run format
+
+      - name: Lint
+        run: pnpm run lint
+
+      - name: Typecheck
+        run: pnpm run typecheck
+
+  ci_ok:
+    name: Typescript CI OK
+    runs-on: ubuntu-latest
+    timeout-minutes: 1
+    if: always()
+    needs: [build_and_test, lint_and_fmt]
+    env:
+      FAILURE: ${{ contains(join(needs.*.result, ','), 'failure') }}
+      CANCELLED: ${{ contains(join(needs.*.result, ','), 'cancelled') }}
+    steps:
+      - name: Check for failure or cancelled jobs result
+        shell: bash
+        run: |
+          echo "Failure: $FAILURE - Cancelled: $CANCELLED"
+          if [ "$FAILURE" = "false" ] && [ "$CANCELLED" = "false" ]; then
+            exit 0
+          else
+            exit 1
+          fi

.github/workflows/typescript.yml

@@ -1,66 +0,0 @@
-name: Typescript CI
-
-on:
-  push:
-    paths:
-      - '.github/**'
-      - 'packages/**'
-  pull_request:
-    paths:
-      - '.github/**'
-      - 'packages/**'
-
-jobs:
-  build-and-test:
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
-    timeout-minutes: 15
-    runs-on: ubuntu-latest
-    
-    steps:    
-    - name: Check out code
-      uses: actions/checkout@v4
-      with:
-        fetch-depth: 2
-
-    - name: Setup Node.js environment
-      uses: actions/setup-node@v4
-      with:
-        node-version: 20
-
-    - name: Install pnpm
-      run: npm i -g pnpm
-        
-    - name: Install dependencies
-      run: pnpm install
-      
-    - name: Build project
-      run: pnpm build
-
-    - name: Test project
-      run: pnpm test
-
-  fmt-lint-and-types:
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-
-    steps:    
-    - name: Check out code
-      uses: actions/checkout@v4
-      with:
-        fetch-depth: 2
-        
-    - name: Install pnpm
-      run: npm i -g pnpm
-       
-    - name: Install dependencies
-      run: pnpm install
-
-    - name: Check formatting
-      run: pnpm format:check
-      
-    - name: Lint
-      run: pnpm lint
- 
-    - name: Types
-      run: pnpm types

.gitignore

@@ -1,12 +1,14 @@
+## Node related ignores
+
 node_modules/
 dist/
 .turbo/
 
 */**/routeTree.gen.ts
 
-pnpm-lock.yaml
+examples/*/pnpm-lock.yaml
 
-examples/playground/
+vite.config.ts.timestamp*
 
 ## Rust related ignores
 
@@ -24,3 +26,7 @@ examples/playground/
 
 # MSVC Windows builds of rustc generate these, which store debugging information
 *.pdb
+
+# Files, generated by the code editors
+.vscode/
+

.nvmrc

@@ -1 +1 @@
-v20.10.0
+22.14.0

.prettierignore

@@ -0,0 +1,11 @@
+pnpm-lock.yaml
+
+dist
+.tuono
+out
+
+vite.config.ts.timestamp-*
+
+packages/tuono-lazy-fn-vite-plugin/tests/sources/*
+
+e2e/fixtures/*/test-results

.prettierrc

@@ -1,4 +1,5 @@
 {
+  "$schema": "https://json.schemastore.org/prettierrc",
   "semi": false,
   "singleQuote": true,
   "trailingComma": "all"

CODEOWNERS

@@ -0,0 +1,9 @@
+*          @Valerioageno @marcalexiei
+
+# Rust
+/crates/    @Valerioageno
+/Cargo.toml @Valerioageno
+
+# Misc
+/.github/   @marcalexiei
+

CODE_OF_CONDUCT.md

@@ -2,7 +2,7 @@
 
 ## Our Pledge
 
-We as members, contributors, and leaders pledge to make participation in our
+We, as members, contributors, and leaders, pledge to make participation in our
 community a harassment-free experience for everyone, regardless of age, body
 size, visible or invisible disability, ethnicity, sex characteristics, gender
 identity and expression, level of experience, education, socio-economic status,
@@ -17,23 +17,23 @@ diverse, inclusive, and healthy community.
 Examples of behavior that contributes to a positive environment for our
 community include:
 
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes,
   and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the
+- Focusing on what is best, not just for us as individuals, but for the
   overall community
 
 Examples of unacceptable behavior include:
 
-* The use of sexualized language or imagery, and sexual attention or
-  advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
+- The use of sexualized language or imagery, and sexual attention or
+  Advances of any kind
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or email
   address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
+- Other conduct that could reasonably be considered inappropriate in a
   professional setting
 
 ## Enforcement Responsibilities
@@ -45,13 +45,13 @@ or harmful.
 
 Community leaders have the right and responsibility to remove, edit, or reject
 comments, commits, code, wiki edits, issues, and other contributions that are
-not aligned to this Code of Conduct, and will communicate reasons for moderation
+not aligned with this Code of Conduct, and will communicate reasons for moderation
 decisions when appropriate.
 
 ## Scope
 
 This Code of Conduct applies within all community spaces, and also applies when
-an individual is officially representing the community in public spaces.
+An individual is officially representing the community in public spaces.
 Examples of representing our community include using an official e-mail address,
 posting via an official social media account, or acting as an appointed
 representative at an online or offline event.
@@ -106,7 +106,7 @@ Violating these terms may lead to a permanent ban.
 ### 4. Permanent Ban
 
 **Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior,  harassment of an
+standards, including sustained inappropriate behavior, harassment of an
 individual, or aggression toward or disparagement of classes of individuals.
 
 **Consequence**: A permanent ban from any sort of public interaction within

CONTRIBUTING.md

@@ -1,21 +1,26 @@
-![](https://github.com/Valerioageno/tuono/actions/workflows/rust.yml/badge.svg)
-![](https://github.com/Valerioageno/tuono/actions/workflows/typescript.yml/badge.svg)
+![](https://github.com/tuono-labs/tuono/actions/workflows/rust.yml/badge.svg)
+![](https://github.com/tuono-labs/tuono/actions/workflows/typescript.yml/badge.svg)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-# How to contribute to Tuono
+# How to Contribute to Tuono
+
+## Contributions
 
-## Contributions 
 Any feature contribution or suggestion is strongly appreciated.
-Since the current project size there isn't yet a defined way to start a discussion. Consider to [open a new issue](https://github.com/Valerioageno/tuono/issues/new)
-or to reach me using my email address [valerioageno@yahoo.it](mailto:valerioageno@ahoo.it). I'm also available on twitter (X) DMs @valerioageno.
+
+We are currently managing the tasks' prioritization in the [Road to V1](https://github.com/orgs/tuono-labs/projects/2) project. You can pick any task that you see in the `ready` column that is not already assigned.
+
+If you want to contribute on something that is in the `backlog` column, or it hasn't been scoped yet, please drop a message in the [#general](https://discord.com/invite/khQzPa654B) discord channel so we can all have visibility of it.
+
+Consider [opening a new issue](https://github.com/tuono-labs/tuono/issues/new/choose) if you find a bug.
 
 ## Bugs
 
 **Did you find a bug?**
-- Ensure the bug was not already reported by searching on GitHub under [Issues](https://github.com/Valerioageno/tuono/issues).
-- If you're unable to find an open issue addressing the problem, [open a new one](https://github.com/Valerioageno/tuono/issues/new). Be sure to include a title and clear description, as much relevant information as possible, and a code sample or an executable test case demonstrating the expected behavior that is not occurring.
+
+- Ensure the bug was not already reported by searching on GitHub under [Issues](https://github.com/tuono-labs/tuono/issues).
+- If you're unable to find an open issue addressing the problem, [open a new one](https://github.com/tuono-labs/tuono/issues/new/choose). Be sure to include a title and clear description, as much relevant information as possible, and a code sample or an executable test case demonstrating the expected behavior that is not occurring.
 
 **Did you write a patch that fixes a bug?**
-- Open a new GitHub pull request with the patch.
-- Ensure the PR description clearly describes the problem and solution. Include the relevant issue number if applicable.
-- The pull requests must pass all the CI pipelines
+
+[Visit the documentation to learn how to open a pull request](https://tuono.dev/documentation/contributing/pull-requests)

Cargo.toml

@@ -1,12 +1,15 @@
 [workspace]
 resolver = "2"
 members = [
-		"crates/tuono",
-		"crates/tuono_lib",
-		"crates/tuono_lib_macros",
+  "crates/tuono", 
+  "crates/tuono_internal", 
+  "crates/tuono_lib", 
+  "crates/tuono_lib_macros"
 ]
 exclude = [
-		"examples/playground",
-		"examples/tuono",
-		"examples/tutorial"
+  "examples/with-mdx",
+  "examples/tuono-app",
+  "examples/tuono-tutorial",
+  "examples/with-tailwind",
+  "e2e/fixtures/base",
 ]

README.md

@@ -1,96 +1,62 @@
-<p align="center">
-  <img src="https://raw.githubusercontent.com/Valerioageno/tuono/main/assets/logo.png" width="200px">
-</p>
-<h1 align="center">Tuono<br>The react/rust fullstack framework</h1>
-<p align="center">
-⚠️ This project is under heavy development. API might drastically change ⚠️
-</p>
-<div align="center">
-    <img src="https://github.com/Valerioageno/tuono/actions/workflows/rust.yml/badge.svg" />
-    <img src="https://github.com/Valerioageno/tuono/actions/workflows/typescript.yml/badge.svg" />
-</div>
+[Documentation](https://tuono.dev) | [Tutorial](https://tuono.dev/documentation/tutorial) |
+[Discord](https://discord.com/invite/khQzPa654B) | [✨Contributing](https://tuono.dev/documentation/contributing)
 
-<br>
-<br>
+# Tuono
 
+<img align="right" src="https://raw.githubusercontent.com/tuono-labs/tuono/main/assets/logo.png" width="160px">
 
-Tuono (Italian word for "thunder", pronounced /2 Oh No/). 
+![](https://github.com/tuono-labs/tuono/actions/workflows/rust.yml/badge.svg)
+![](https://github.com/tuono-labs/tuono/actions/workflows/typescript.yml/badge.svg)
+
+**Tuono is a full-stack web framework for building React applications using Rust as the backend with
+a strong focus on usability and performance.**
+
+Tuono (Italian word for "thunder", pronounced /2 Oh No/).
 Why Tuono? Just a badass name.
 
-> Check out the [tutorial](https://github.com/Valerioageno/tuono/blob/main/docs/tutorial.md) to get started.
+If you have experience with [Next.js](https://nextjs.org/) you will feel home here.
 
-## Introduction
+Some of its features are:
 
-**NodeJs/Deno/Bun are the only runtimes that allow a React app to be fullstack right? (no)**
+- 🟦 Native Typescript
+- 🌐 Next.js like Routing
+- 🍭 CSS/SCSS modules
+- 🧬 Server Side Rendering
+- 🔥 Hot Module Reload
 
-Tuono is a fullstack React framework with the server side written in Rust. 
-Because of this Tuono is extremely fast and the requests are handled by multithreaded Rust server.
-React is still React - it is just superpowered.
+## Documentation
 
-**Rust is an hard language then writing server side code is hard as well right? (no again)**
+The [documentation](https://tuono.dev/) is available on
+[tuono.dev](https://tuono.dev/).
 
-Tuono provides a collection of utilities to handle the server side code seamlessly with the React code.
-Each server side route is managed with a separate file alongside the React route. The routing is handled
-by Tuono based on the files defined within the `./src/routes` directory.
+## Installation
 
-## Features
+Available on MacOS, Linux and Windows.
 
-- 🟦  Typescript
-- 🌐  Routing
-- 🔥  Hot Module Reload
-- 🍭  CSS modules
-- 🧬  Server Side Rendering
-- 🧵  Multi thread backend
-- ⚙️   Build optimizations
-- Custom APIs*
-- Image optimization*
-- Server streamed content*
-
-> *Development in progress
+```sh
+cargo install tuono
+```
 
 ## Getting started
 
-As already mentioned above I strongly suggest you to take a look at the
-[tutorial](https://github.com/Valerioageno/tuono/blob/main/docs/tutorial.md).
-
-Tuono is basically a CLI that provides all the commands to handle the fullstack project. 
-To download it you need [cargo](https://doc.rust-lang.org/cargo/) which is the [rust](https://www.rust-lang.org/)
-package manager.
-
-To download and install it you just need to run `cargo install tuono`.
-
-To create a new project run `tuono new [NAME]` (optionally you can pass the `--template` flag - check the 
-[examples](https://github.com/Valerioageno/tuono/tree/main/examples) folder).
-
-Then to run the local development environment run inside the project folder `tuono dev`
-
-Finally when the project will be ready to be deployed just run `tuono build` to create the final React assets
-and to set the server project to the `production` mode.
-
-Now to execute it just run `cargo run --release`.
-
-## Requirements
-
-- rust
-- cargo
-- node
-- pnpm (other package managers support will be added soon)
-
-## Folder structure
+Create a new project with:
 
+```sh
+tuono new [PROJECT_NAME]
 ```
-├── package.json
-├── public
-├── src
-│   ├── routes
-│   └── styles
-├── Cargo.toml
-├── README.md
-└── tsconfig.json
+
+> You can optionally pass the --template (or -t) flag to directly start from a [template](https://github.com/tuono-labs/tuono/tree/main/examples)
+
+Now just install the dependencies with you favourite JS package manager (i.e. `npm install`) and start the development environment
+
+```sh
+tuono dev
 ```
 
 ## Contributing
+
 Any help or suggestion will be appreciated and encouraged.
+Check the [✨Contributing](https://tuono.dev/documentation/contributing) page
 
 ## License
 

crates/tuono/Cargo.toml

@@ -1,17 +1,16 @@
 [package]
 name = "tuono"
-version = "0.2.2"
-edition = "2021"
+version = "0.19.1"
+edition = "2024"
 authors = ["V. Ageno <valerioageno@yahoo.it>"]
-description = "The react/rust fullstack framework"
-repository = "https://github.com/Valerioageno/tuono"
+description = "Superfast React fullstack framework"
+homepage = "https://tuono.dev"
+keywords = ["react", "typescript", "fullstack", "web", "ssr"]
+repository = "https://github.com/tuono-labs/tuono"
 readme = "../../README.md"
 license-file = "../../LICENSE.md"
-categories = ["web-programming", "reactjs", "typescript", "framework", "fullstack"]
-include = [
-		"src/*.rs",
-		"Cargo.toml"
-]
+categories = ["web-programming"]
+include = ["src/**/*.rs", "templates/*", "Cargo.toml"]
 
 [lib]
 name = "tuono"
@@ -19,14 +18,27 @@ path = "src/lib.rs"
 
 [dependencies]
 clap = { version = "4.5.4", features = ["derive", "cargo"] }
-watchexec = "4.0.0"
+watchexec = "5.0.0"
+tracing = "0.1.41"
+tracing-subscriber = {version = "0.3.19", features = ["env-filter"]}
 miette = "7.2.0"
-watchexec-signals = "3.0.0"
+watchexec-signals = "4.0.0"
 tokio = { version = "1", features = ["full"] }
 serde = { version = "1.0.202", features = ["derive"] }
-watchexec-supervisor = "2.0.0"
+watchexec-supervisor = "3.0.0"
 glob = "0.3.1"
 regex = "1.10.4"
-reqwest = {version = "0.12.4", features =["blocking", "json"]}
+reqwest = { version = "0.12.4", features = ["blocking", "json"] }
 serde_json = "1.0"
+fs_extra = "1.3.0"
+http = "1.1.0"
+tuono_internal = {path = "../tuono_internal", version = "0.19.1"}
+spinners = "4.1.1"
+console = "0.15.10"
+
+[dev-dependencies]
+wiremock = "0.6.2"
+tempfile = "3.14.0"
+assert_cmd = "2.0.16"
+serial_test = "3.0.0"
 

crates/tuono/src/app.rs

@@ -0,0 +1,521 @@
+use crate::mode::Mode;
+use crate::route::Route;
+use glob::GlobError;
+use glob::glob;
+use http::Method;
+use std::collections::hash_set::HashSet;
+use std::collections::{HashMap, hash_map::Entry};
+use std::fs::File;
+use std::io;
+use std::io::BufReader;
+use std::io::prelude::*;
+use std::path::Path;
+use std::path::PathBuf;
+use std::process::Child;
+use std::process::Command;
+use std::process::Stdio;
+use tracing::error;
+use tuono_internal::config::Config;
+
+const IGNORE_EXTENSIONS: [&str; 3] = ["css", "scss", "sass"];
+const IGNORE_FILES: [&str; 1] = ["__layout"];
+
+#[cfg(target_os = "windows")]
+const ROUTES_FOLDER_PATH: &str = "\\src\\routes";
+#[cfg(target_os = "windows")]
+const BUILD_JS_SCRIPT: &str = ".\\node_modules\\.bin\\tuono-build-prod.cmd";
+
+#[cfg(target_os = "windows")]
+const BUILD_TUONO_CONFIG: &str = ".\\node_modules\\.bin\\tuono-build-config.cmd";
+
+#[cfg(not(target_os = "windows"))]
+const ROUTES_FOLDER_PATH: &str = "/src/routes";
+#[cfg(not(target_os = "windows"))]
+const BUILD_JS_SCRIPT: &str = "./node_modules/.bin/tuono-build-prod";
+
+#[cfg(not(target_os = "windows"))]
+const BUILD_TUONO_CONFIG: &str = "./node_modules/.bin/tuono-build-config";
+
+#[derive(Debug, Clone)]
+pub struct App {
+    pub route_map: HashMap<String, Route>,
+    pub base_path: PathBuf,
+    pub has_app_state: bool,
+    pub config: Option<Config>,
+}
+
+fn has_app_state(base_path: PathBuf) -> std::io::Result<bool> {
+    let file = File::open(base_path.join("src/app.rs"))?;
+    let mut buf_reader = BufReader::new(file);
+    let mut contents = String::new();
+    buf_reader.read_to_string(&mut contents)?;
+    Ok(contents.contains("pub fn main"))
+}
+
+impl App {
+    pub fn new() -> Self {
+        let base_path = std::env::current_dir().expect("Failed to read current_dir");
+
+        let mut app = App {
+            route_map: HashMap::new(),
+            base_path: base_path.clone(),
+            has_app_state: has_app_state(base_path).unwrap_or(false),
+            config: None,
+        };
+
+        app.collect_routes();
+
+        app
+    }
+
+    pub fn collect_routes(&mut self) {
+        glob(
+            self.base_path
+                .join("src/routes/**/*.*")
+                .to_str()
+                .expect("Failed to glob routes folder"),
+        )
+        .expect("Failed to read glob pattern")
+        .for_each(|entry| {
+            if self.should_collect_route(&entry) {
+                self.collect_route(entry)
+            }
+        })
+    }
+
+    fn should_collect_route(&self, entry: &Result<PathBuf, GlobError>) -> bool {
+        let file_extension = entry
+            .as_ref()
+            .unwrap()
+            .extension()
+            .expect("Failed to read file extension");
+        let file_name = entry
+            .as_ref()
+            .unwrap()
+            .file_stem()
+            .expect("Failed to read file name");
+
+        if IGNORE_EXTENSIONS.iter().any(|val| val == &file_extension) {
+            return false;
+        }
+
+        if IGNORE_FILES.iter().any(|val| val == &file_name) {
+            return false;
+        }
+        true
+    }
+
+    fn collect_route(&mut self, path_buf: Result<PathBuf, GlobError>) {
+        let entry = path_buf.expect("Failed to read glob path");
+
+        let base_path_str = self
+            .base_path
+            .to_str()
+            .expect("Failed to read as str base_path");
+        let path = entry
+            .to_str()
+            .expect("Failed to read entry as str")
+            .replace(&format!("{base_path_str}{ROUTES_FOLDER_PATH}"), "")
+            // Cleanup windows paths
+            .replace("\\", "/")
+            .replace(".rs", "")
+            .replace(".mdx", "")
+            .replace(".tsx", "");
+
+        if entry.extension().expect("failed to read entry extension") == "rs" {
+            if let Entry::Vacant(route_map) = self.route_map.entry(path.clone()) {
+                let mut route = Route::new(path);
+                route.update_axum_info();
+                route_map.insert(route);
+            } else {
+                let route = self.route_map.get_mut(&path).unwrap();
+                route.update_axum_info();
+            }
+            return;
+        }
+        if let Entry::Vacant(route_map) = self.route_map.entry(path.clone()) {
+            let route = Route::new(path);
+            route_map.insert(route);
+        }
+    }
+
+    pub fn has_dynamic_routes(&self) -> bool {
+        self.route_map.iter().any(|(_, route)| route.is_dynamic)
+    }
+
+    pub fn check_server_availability(&self, mode: Mode) {
+        // At this point the config should be available
+        let config = self.config.as_ref().unwrap();
+
+        let rust_listener =
+            std::net::TcpListener::bind(format!("{}:{}", config.server.host, config.server.port));
+
+        if let Err(_e) = rust_listener {
+            eprintln!("Error: Failed to bind to port {}", config.server.port);
+            eprintln!(
+                "Please ensure that port {} is not already in use by another process or application.",
+                config.server.port
+            );
+            std::process::exit(1);
+        }
+
+        if mode == Mode::Dev {
+            let vite_port = config.server.port + 1;
+            let vite_listener =
+                std::net::TcpListener::bind(format!("{}:{}", config.server.host, vite_port));
+
+            if let Err(_e) = vite_listener {
+                eprintln!("Error: Failed to bind to port {}", vite_port);
+                eprintln!(
+                    "Please ensure that port {} is not already in use by another process or application.",
+                    vite_port
+                );
+                std::process::exit(1);
+            }
+        }
+    }
+
+    pub fn build_react_prod(&self) {
+        if !Path::new(BUILD_JS_SCRIPT).exists() {
+            error!("Failed to find the build script. Please run `npm install`");
+            std::process::exit(1);
+        }
+
+        let output = Command::new(BUILD_JS_SCRIPT).output().unwrap_or_else(|_| {
+            error!("Failed to build the react source");
+            std::process::exit(1);
+        });
+
+        if !output.status.success() {
+            error!("Failed to build the react source");
+            error!("Error: {}", String::from_utf8_lossy(&output.stderr));
+            std::process::exit(1);
+        }
+    }
+
+    pub fn run_rust_server(&self) -> Child {
+        Command::new("cargo")
+            .arg("run")
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()
+            .expect("Failed to run the rust server")
+    }
+
+    pub fn build_tuono_config(&mut self) -> io::Result<std::process::Output> {
+        if !Path::new(BUILD_TUONO_CONFIG).exists() {
+            eprintln!("Failed to find the build script. Please run `npm install`");
+            std::process::exit(1);
+        }
+
+        let config_build_command = Command::new(BUILD_TUONO_CONFIG)
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .output();
+
+        match Config::get() {
+            Ok(config) => self.config = Some(config),
+            Err(error) => {
+                match error.kind() {
+                    io::ErrorKind::NotFound => eprintln!(
+                        "Failed to read config. Please run `npm install` to generate automatically."
+                    ),
+                    _ => {
+                        error!("Failed to read config with the following error:");
+                        error!("{}", error);
+                    }
+                }
+                std::process::exit(1);
+            }
+        }
+
+        config_build_command
+    }
+    pub fn get_used_http_methods(&self) -> HashSet<Method> {
+        let mut acc = HashSet::new();
+
+        for (_, route) in self.route_map.clone().into_iter() {
+            if route.axum_info.is_some() {
+                acc.insert(Method::GET);
+            }
+            if !route.is_api() {
+                continue;
+            }
+            for method in route.api_data.unwrap().methods.into_iter() {
+                acc.insert(method);
+            }
+        }
+
+        acc
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[test]
+    fn should_collect_routes() {
+        let mut app = App::new();
+        #[cfg(target_os = "windows")]
+        let base_path = "\\home\\user\\Documents\\tuono";
+
+        #[cfg(not(target_os = "windows"))]
+        let base_path = "/home/user/Documents/tuono";
+
+        app.base_path = base_path.into();
+
+        #[cfg(target_os = "windows")]
+        let routes = [
+            "\\home\\user\\Documents\\tuono\\src\\routes\\about.rs",
+            "\\home\\user\\Documents\\tuono\\src\\routes\\index.rs",
+            "\\home\\user\\Documents\\tuono\\src\\routes\\posts\\index.rs",
+            "\\home\\user\\Documents\\tuono\\src\\routes\\posts\\[post].rs",
+            "\\home\\user\\Documents\\tuono\\src\\routes\\posts\\handle-this.rs",
+            "\\home\\user\\Documents\\tuono\\src\\routes\\posts\\handle-this\\[post].rs",
+            "\\home\\user\\Documents\\tuono\\src\\routes\\posts\\UPPERCASE.rs",
+            "\\home\\user\\Documents\\tuono\\src\\routes\\sitemap.xml.rs",
+        ];
+
+        #[cfg(not(target_os = "windows"))]
+        let routes = [
+            "/home/user/Documents/tuono/src/routes/about.rs",
+            "/home/user/Documents/tuono/src/routes/index.rs",
+            "/home/user/Documents/tuono/src/routes/posts/index.rs",
+            "/home/user/Documents/tuono/src/routes/posts/[post].rs",
+            "/home/user/Documents/tuono/src/routes/posts/handle-this.rs",
+            "/home/user/Documents/tuono/src/routes/posts/handle-this/[post].rs",
+            "/home/user/Documents/tuono/src/routes/posts/UPPERCASE.rs",
+            "/home/user/Documents/tuono/src/routes/sitemap.xml.rs",
+        ];
+
+        routes
+            .into_iter()
+            .for_each(|route| app.collect_route(Ok(PathBuf::from(route))));
+
+        let results = [
+            ("/index", "index"),
+            ("/about", "about"),
+            ("/posts/index", "posts_index"),
+            ("/posts/[post]", "posts_dyn_post"),
+            ("/posts/handle-this", "posts_handle_hyphen_this"),
+            (
+                "/posts/handle-this/[post]",
+                "posts_handle_hyphen_this_dyn_post",
+            ),
+            ("/posts/UPPERCASE", "posts_uppercase"),
+            ("/sitemap.xml", "sitemap_dot_xml"),
+        ];
+
+        results.into_iter().for_each(|(path, module_import)| {
+            assert_eq!(
+                app.route_map
+                    .get(path)
+                    .unwrap()
+                    .axum_info
+                    .as_ref()
+                    .unwrap()
+                    .module_import,
+                String::from(module_import)
+            )
+        })
+    }
+
+    #[test]
+    fn should_create_multi_level_axum_paths() {
+        let mut app = App::new();
+
+        #[cfg(target_os = "windows")]
+        let base_path = "\\home\\user\\Documents\\tuono";
+
+        #[cfg(not(target_os = "windows"))]
+        let base_path = "/home/user/Documents/tuono";
+
+        app.base_path = base_path.into();
+
+        #[cfg(target_os = "windows")]
+        let routes = [
+            "\\home\\user\\Documents\\tuono\\src\\routes\\about.rs",
+            "\\home\\user\\Documents\\tuono\\src\\routes\\index.rs",
+            "\\home\\user\\Documents\\tuono\\src\\routes\\posts\\index.rs",
+            "\\home\\user\\Documents\\tuono\\src\\routes\\posts\\any-post.rs",
+            "\\home\\user\\Documents\\tuono\\src\\routes\\posts\\[post].rs",
+        ];
+
+        #[cfg(not(target_os = "windows"))]
+        let routes = [
+            "/home/user/Documents/tuono/src/routes/about.rs",
+            "/home/user/Documents/tuono/src/routes/index.rs",
+            "/home/user/Documents/tuono/src/routes/posts/index.rs",
+            "/home/user/Documents/tuono/src/routes/posts/any-post.rs",
+            "/home/user/Documents/tuono/src/routes/posts/[post].rs",
+        ];
+
+        routes
+            .into_iter()
+            .for_each(|route| app.collect_route(Ok(PathBuf::from(route))));
+
+        let results = [
+            ("/index", "/"),
+            ("/about", "/about"),
+            ("/posts/index", "/posts"),
+            ("/posts/any-post", "/posts/any-post"),
+            ("/posts/[post]", "/posts/{post}"),
+        ];
+
+        results.into_iter().for_each(|(path, expected_path)| {
+            assert_eq!(
+                app.route_map
+                    .get(path)
+                    .expect("Failed to get route path")
+                    .axum_info
+                    .as_ref()
+                    .unwrap()
+                    .axum_route,
+                String::from(expected_path)
+            )
+        })
+    }
+
+    #[test]
+    fn should_ignore_whitelisted_extensions() {
+        let mut app = App::new();
+        app.base_path = "/home/user/Documents/tuono".into();
+
+        let routes = [
+            "/home/user/Documents/tuono/src/routes/about.css",
+            "/home/user/Documents/tuono/src/routes/index.scss",
+            "/home/user/Documents/tuono/src/routes/posts/index.sass",
+        ];
+
+        routes.into_iter().for_each(|route| {
+            if app.should_collect_route(&Ok(PathBuf::from(route))) {
+                app.collect_route(Ok(PathBuf::from(route)))
+            }
+        });
+
+        assert!(app.route_map.is_empty())
+    }
+
+    #[test]
+    fn should_ignore_whitelisted_files() {
+        let mut app = App::new();
+        app.base_path = "/home/user/Documents/tuono".into();
+
+        let routes = [
+            "/home/user/Documents/tuono/src/routes/__layout.tsx",
+            "/home/user/Documents/tuono/src/routes/posts/__layout.tsx",
+        ];
+
+        routes.into_iter().for_each(|route| {
+            if app.should_collect_route(&Ok(PathBuf::from(route))) {
+                app.collect_route(Ok(PathBuf::from(route)))
+            }
+        });
+
+        assert!(app.route_map.is_empty())
+    }
+
+    #[test]
+    fn should_correctly_parse_routes_with_server_handler() {
+        let mut app = App::new();
+
+        #[cfg(target_os = "windows")]
+        let base_path = "\\home\\user\\Documents\\tuono";
+
+        #[cfg(not(target_os = "windows"))]
+        let base_path = "/home/user/Documents/tuono";
+
+        app.base_path = base_path.into();
+
+        #[cfg(target_os = "windows")]
+        let routes = [
+            "\\home\\user\\Documents\\tuono\\src\\routes\\about.rs",
+            "\\home\\user\\Documents/tuono\\src\\routes\\about.tsx",
+            "\\home\\user\\Documents\\tuono\\src\\routes\\index.tsx",
+        ];
+
+        #[cfg(not(target_os = "windows"))]
+        let routes = [
+            "/home/user/Documents/tuono/src/routes/about.rs",
+            "/home/user/Documents/tuono/src/routes/about.tsx",
+            "/home/user/Documents/tuono/src/routes/index.tsx",
+        ];
+
+        routes
+            .into_iter()
+            .for_each(|route| app.collect_route(Ok(PathBuf::from(route))));
+
+        let results = [("/about", true), ("/index", false)];
+
+        results
+            .into_iter()
+            .for_each(|(path, expected_has_server_handler)| {
+                if expected_has_server_handler {
+                    assert!(
+                        app.route_map
+                            .get(path)
+                            .expect("Failed to get route path")
+                            .axum_info
+                            .is_some()
+                    )
+                } else {
+                    assert!(
+                        app.route_map
+                            .get(path)
+                            .expect("Failed to get route path")
+                            .axum_info
+                            .is_none()
+                    )
+                }
+            })
+    }
+
+    #[test]
+    fn has_dynamic_routes_works() {
+        let mut app = App::new();
+        app.base_path = "/home/user/Documents/tuono".into();
+
+        let routes = [
+            "/home/user/Documents/tuono/src/routes/index.rs",
+            "/home/user/Documents/tuono/src/routes/posts/[post].rs",
+        ];
+
+        routes
+            .into_iter()
+            .for_each(|route| app.collect_route(Ok(PathBuf::from(route))));
+
+        assert!(app.has_dynamic_routes());
+
+        let mut app2 = App::new();
+        app2.base_path = "/home/user/Documents/tuono".into();
+
+        let routes = [
+            "/home/user/Documents/tuono/src/routes/[post].rs",
+            "/home/user/Documents/tuono/src/routes/posts/[post].rs",
+        ];
+
+        routes
+            .into_iter()
+            .for_each(|route| app2.collect_route(Ok(PathBuf::from(route))));
+
+        assert!(app2.has_dynamic_routes());
+
+        let mut app3 = App::new();
+        app3.base_path = "/home/user/Documents/tuono".into();
+
+        let routes = [
+            "/home/user/Documents/tuono/src/routes/index.rs",
+            "/home/user/Documents/tuono/src/routes/posts/index.rs",
+        ];
+
+        routes
+            .into_iter()
+            .for_each(|route| app3.collect_route(Ok(PathBuf::from(route))));
+
+        assert!(!app3.has_dynamic_routes())
+    }
+}

crates/tuono/src/cli.rs

@@ -0,0 +1,83 @@
+use clap::{Parser, Subcommand};
+use tracing::{Level, span};
+
+use crate::commands::{build, dev, new};
+use crate::mode::Mode;
+use crate::source_builder::SourceBuilder;
+
+#[derive(Subcommand, Debug)]
+enum Actions {
+    /// Start the development environment
+    Dev,
+    /// Build the production assets
+    Build {
+        #[arg(short, long = "static")]
+        /// Statically generate the website HTML
+        ssg: bool,
+
+        #[arg(short, long)]
+        /// Prevent to export the js assets
+        no_js_emit: bool,
+    },
+    /// Scaffold a new project
+    New {
+        /// The folder in which load the project. Default is the current directory.
+        folder_name: Option<String>,
+        /// The template to use to scaffold the project. The template should match one of the tuono
+        /// examples
+        #[arg(short, long)]
+        template: Option<String>,
+        /// Load the latest commit available on the main branch
+        #[arg(long)]
+        head: Option<bool>,
+    },
+}
+
+#[derive(Parser, Debug)]
+#[command(version, about = "The React/Rust full-stack framework")]
+struct Args {
+    #[command(subcommand)]
+    action: Actions,
+}
+
+pub fn app() -> std::io::Result<()> {
+    let args = Args::parse();
+
+    match args.action {
+        Actions::Dev => {
+            let span = span!(Level::TRACE, "DEV");
+
+            let _guard = span.enter();
+
+            let mut source_builder = SourceBuilder::new(Mode::Dev)?;
+
+            source_builder.base_build()?;
+
+            source_builder.app.check_server_availability(Mode::Dev);
+
+            dev::watch(source_builder).unwrap();
+        }
+        Actions::Build { ssg, no_js_emit } => {
+            let span = span!(Level::TRACE, "BUILD");
+
+            let _guard = span.enter();
+
+            let mut source_builder = SourceBuilder::new(Mode::Prod)?;
+            source_builder.base_build()?;
+            build::build(source_builder.app, ssg, no_js_emit);
+        }
+        Actions::New {
+            folder_name,
+            template,
+            head,
+        } => {
+            let span = span!(Level::TRACE, "NEW");
+
+            let _guard = span.enter();
+
+            new::create_new_project(folder_name, template, head);
+        }
+    }
+
+    Ok(())
+}

crates/tuono/src/commands/build.rs

@@ -0,0 +1,118 @@
+use fs_extra::dir::{CopyOptions, copy};
+use spinners::{Spinner, Spinners};
+use std::path::PathBuf;
+use std::thread::sleep;
+use std::time::Duration;
+use tracing::{error, trace};
+
+use crate::app::App;
+use crate::mode::Mode;
+
+fn exit_gracefully_with_error(msg: &str) -> ! {
+    error!(msg);
+    std::process::exit(1);
+}
+
+pub fn build(mut app: App, ssg: bool, no_js_emit: bool) {
+    if no_js_emit {
+        println!("Rust build successfully finished");
+        std::process::exit(0);
+    }
+
+    if ssg && app.has_dynamic_routes() {
+        // TODO: allow dynamic routes static generation
+        println!("Cannot statically build dynamic routes");
+        std::process::exit(1);
+    }
+
+    app.build_tuono_config()
+        .unwrap_or_else(|_| exit_gracefully_with_error("Failed to build tuono.config.ts"));
+
+    let mut app_build_spinner = Spinner::new(Spinners::Dots, "Building app...".into());
+
+    app.check_server_availability(Mode::Prod);
+
+    app.build_react_prod();
+
+    // Remove the spinner
+    app_build_spinner.stop_with_message("\u{2705}Build completed".into());
+
+    if ssg {
+        let mut app_build_static_spinner =
+            Spinner::new(Spinners::Dots, "Static site generation".into());
+
+        let mut exit_gracefully_with_error = |msg: &str| -> ! {
+            app_build_static_spinner.stop_with_message("\u{274C} Build failed\n".into());
+            exit_gracefully_with_error(msg)
+        };
+
+        let static_dir = PathBuf::from("out/static");
+
+        if static_dir.is_dir() {
+            std::fs::remove_dir_all(&static_dir).unwrap_or_else(|_| {
+                exit_gracefully_with_error("Failed to clear the out/static folder")
+            });
+        }
+
+        std::fs::create_dir(&static_dir)
+            .unwrap_or_else(|_| exit_gracefully_with_error("Failed to create static output dir"));
+
+        copy(
+            "./out/client",
+            static_dir,
+            &CopyOptions::new().overwrite(true).content_only(true),
+        )
+        .unwrap_or_else(|_| {
+            exit_gracefully_with_error("Failed to clone assets into static output folder")
+        });
+
+        // Start the server
+        #[allow(clippy::zombie_processes)]
+        let mut rust_server = app.run_rust_server();
+
+        let mut exit_and_shut_server = |msg: &str| -> ! {
+            _ = rust_server.kill();
+            exit_gracefully_with_error(msg)
+        };
+
+        let reqwest_client = reqwest::blocking::Client::builder()
+            .user_agent("")
+            .build()
+            .unwrap_or_else(|_| exit_and_shut_server("Failed to build reqwest client"));
+
+        // Wait for server
+        let mut is_server_ready = false;
+        let config = app.config.as_ref().unwrap();
+
+        while !is_server_ready {
+            trace!("Checking server availability");
+
+            let server_url = match &config.server.origin {
+                Some(origin) => origin.clone(),
+                None => format!("http://{}:{}", config.server.host, config.server.port),
+            };
+
+            if reqwest_client.get(&server_url).send().is_ok() {
+                is_server_ready = true;
+            } else {
+                trace!("Server not ready yet. Sleeping for 1 second");
+            }
+
+            sleep(Duration::from_secs(1));
+        }
+
+        trace!("Server is ready, starting static site generation");
+
+        for (_, route) in app.route_map {
+            if let Err(msg) = route.save_ssg_file(&reqwest_client) {
+                exit_and_shut_server(&msg);
+            }
+        }
+
+        // Close server
+        let _ = rust_server.kill();
+
+        app_build_static_spinner
+            .stop_with_message("\u{2705}Static site generation completed".into());
+    }
+}

crates/tuono/src/commands/dev.rs

@@ -0,0 +1,171 @@
+use std::fs;
+use std::path::Path;
+use std::sync::{Arc, RwLock};
+use watchexec_supervisor::command::{Command, Program};
+
+use miette::{IntoDiagnostic, Result};
+use watchexec::Watchexec;
+use watchexec_signals::Signal;
+use watchexec_supervisor::job::{Job, start_job};
+
+use crate::source_builder::SourceBuilder;
+use console::Term;
+use spinners::{Spinner, Spinners};
+
+#[cfg(target_os = "windows")]
+const DEV_WATCH_BIN_SRC: &str = "node_modules\\.bin\\tuono-dev-watch.cmd";
+#[cfg(target_os = "windows")]
+const DEV_SSR_BIN_SRC: &str = "node_modules\\.bin\\tuono-dev-ssr.cmd";
+
+#[cfg(not(target_os = "windows"))]
+const DEV_WATCH_BIN_SRC: &str = "node_modules/.bin/tuono-dev-watch";
+#[cfg(not(target_os = "windows"))]
+const DEV_SSR_BIN_SRC: &str = "node_modules/.bin/tuono-dev-ssr";
+
+fn watch_react_src() -> Job {
+    if !Path::new(DEV_SSR_BIN_SRC).exists() {
+        eprintln!("Failed to find script to run dev watch. Please run `npm install`");
+        std::process::exit(1);
+    }
+    start_job(Arc::new(Command {
+        program: Program::Exec {
+            prog: DEV_WATCH_BIN_SRC.into(),
+            args: vec![],
+        },
+        options: Default::default(),
+    }))
+    .0
+}
+
+fn run_rust_dev_server() -> Job {
+    start_job(Arc::new(Command {
+        program: Program::Exec {
+            prog: "cargo".into(),
+            args: vec!["run".to_string(), "-q".to_string()],
+        },
+        options: Default::default(),
+    }))
+    .0
+}
+
+fn build_rust_src() -> Job {
+    start_job(Arc::new(Command {
+        program: Program::Exec {
+            prog: "cargo".into(),
+            args: vec!["build".to_string(), "-q".to_string()],
+        },
+        options: Default::default(),
+    }))
+    .0
+}
+
+fn build_react_ssr_src() -> Job {
+    if !Path::new(DEV_SSR_BIN_SRC).exists() {
+        eprintln!("Failed to find script to run dev ssr. Please run `npm install`");
+        std::process::exit(1);
+    }
+    start_job(Arc::new(Command {
+        program: Program::Exec {
+            prog: DEV_SSR_BIN_SRC.into(),
+            args: vec![],
+        },
+        options: Default::default(),
+    }))
+    .0
+}
+
+fn ssr_reload_needed(path: &Path) -> bool {
+    let file_name_starts_with_env = path
+        .file_name()
+        .map(|f| f.to_string_lossy().starts_with(".env"))
+        .unwrap_or(false);
+
+    let file_path = path.to_string_lossy();
+
+    file_name_starts_with_env || file_path.ends_with("sx") || file_path.ends_with("mdx")
+}
+
+#[tokio::main]
+pub async fn watch(source_builder: SourceBuilder) -> Result<()> {
+    let source_builder = RwLock::new(source_builder);
+    let term = Term::stdout();
+    let mut sp = Spinner::new(Spinners::Dots, "Starting dev server...".into());
+
+    watch_react_src().start().await;
+
+    let rust_server = run_rust_dev_server();
+    let build_rust_src = build_rust_src();
+
+    let build_ssr_bundle = build_react_ssr_src();
+
+    let env_files = fs::read_dir("./")
+        .expect("Error reading env files from current directory")
+        .filter_map(|entry| entry.ok())
+        .filter(|entry| entry.file_name().to_string_lossy().starts_with(".env"))
+        .map(|entry| entry.path().to_string_lossy().into_owned())
+        .collect::<Vec<String>>();
+
+    build_ssr_bundle.start().await;
+    build_rust_src.start().await;
+
+    // Wait vite and rust builds
+    build_ssr_bundle.to_wait().await;
+    build_rust_src.to_wait().await;
+
+    rust_server.start().await;
+
+    // Remove the spinner
+    sp.stop();
+    _ = term.clear_line();
+
+    let wx = Watchexec::new(move |mut action| {
+        let mut should_reload_ssr_bundle = false;
+        let mut should_reload_rust_server = false;
+
+        for event in action.events.iter() {
+            for path in event.paths() {
+                let file_path = path.0.to_string_lossy();
+                if file_path.ends_with(".rs") {
+                    // TODO: only the new file show trigger a axum refresh.
+                    // Update of existing file should just reload the server.
+                    should_reload_rust_server = true
+                }
+
+                if ssr_reload_needed(path.0) {
+                    should_reload_ssr_bundle = true
+                }
+            }
+        }
+
+        if should_reload_rust_server {
+            println!("  Reloading...");
+            rust_server.stop();
+            if let Ok(mut builder) = source_builder.write() {
+                builder.app.collect_routes();
+                _ = builder.refresh_axum_source();
+            }
+            rust_server.start();
+        }
+
+        if should_reload_ssr_bundle {
+            build_ssr_bundle.stop();
+            build_ssr_bundle.start();
+        }
+
+        // if Ctrl-C is received, quit
+        if action.signals().any(|sig| sig == Signal::Interrupt) {
+            action.quit();
+        }
+
+        action
+    })?;
+
+    // watch the current directory and all types of .env file
+    let mut paths_to_watch = vec!["./src".to_string()];
+    paths_to_watch.extend(env_files);
+
+    wx.config.pathset(paths_to_watch);
+
+    let _ = wx.main().await.into_diagnostic()?;
+    Ok(())
+}

crates/tuono/src/commands/mod.rs

@@ -0,0 +1,3 @@
+pub mod build;
+pub mod dev;
+pub mod new;

crates/tuono/src/commands/new.rs

@@ -0,0 +1,317 @@
+use clap::crate_version;
+use reqwest::blocking;
+use reqwest::blocking::Client;
+use serde::Deserialize;
+use std::env;
+use std::fs::{self, File, OpenOptions, create_dir};
+use std::io::{self, prelude::*};
+use std::path::{Path, PathBuf};
+
+#[derive(Deserialize, Debug)]
+enum GithubFileType {
+    #[serde(rename = "blob")]
+    Blob,
+    #[serde(rename = "tree")]
+    Tree,
+}
+
+#[derive(Deserialize, Debug)]
+struct GithubTagObject {
+    sha: String,
+}
+
+#[derive(Deserialize, Debug)]
+struct GithubTagResponse {
+    object: GithubTagObject,
+}
+
+#[derive(Deserialize, Debug)]
+struct GithubTreeResponse<T> {
+    tree: Vec<T>,
+}
+
+fn exit_with_error(message: &str) -> ! {
+    eprintln!("{}", message);
+    std::process::exit(1);
+}
+
+#[derive(Deserialize, Debug)]
+struct GithubFile {
+    path: String,
+    #[serde(rename(deserialize = "type"))]
+    element_type: GithubFileType,
+}
+
+fn create_file(path: PathBuf, content: String) -> std::io::Result<()> {
+    let mut file = File::create(&path).unwrap_or_else(|err| {
+        exit_with_error(&format!(
+            "Failed to create file {}: {}",
+            path.display(),
+            err
+        ));
+    });
+    let _ = file.write_all(content.as_bytes());
+
+    Ok(())
+}
+
+pub fn create_new_project(
+    folder_name: Option<String>,
+    template: Option<String>,
+    select_head: Option<bool>,
+) {
+    let folder = folder_name.unwrap_or(".".to_string());
+
+    let github_api_base_url =
+        env::var("__INTERNAL_TUONO_TEST").unwrap_or("https://api.github.com".to_string());
+
+    let github_raw_base_url = env::var("__INTERNAL_TUONO_TEST")
+        .unwrap_or("https://raw.githubusercontent.com".to_string());
+
+    // In case of missing select the tuono example
+    let template = template.unwrap_or("tuono-app".to_string());
+    let client = blocking::Client::builder()
+        .user_agent("")
+        .build()
+        .unwrap_or_else(|_| exit_with_error("Error: Failed to build request client"));
+
+    // This string does not include the "v" version prefix
+    let cli_version: &str = crate_version!();
+
+    let tree_url: String =
+        generate_tree_url(select_head, &client, cli_version, &github_api_base_url);
+
+    let res_tree = client
+        .get(tree_url)
+        .send()
+        .unwrap_or_else(|_| {
+            exit_with_error(&format!(
+                "Failed to call the tagged commit tree github API for v{cli_version}"
+            ))
+        })
+        .json::<GithubTreeResponse<GithubFile>>()
+        .expect("Failed to parse the tree structure");
+
+    let new_project_files = res_tree
+        .tree
+        .iter()
+        .filter(|GithubFile { path, .. }| path.starts_with(&format!("examples/{template}/")))
+        .collect::<Vec<&GithubFile>>();
+
+    if new_project_files.is_empty() {
+        eprintln!("Error: Template '{template}' not found");
+        println!(
+            "Hint: you can view the available templates at https://github.com/tuono-labs/tuono/tree/main/examples"
+        );
+        std::process::exit(1);
+    }
+
+    if folder != "." {
+        if Path::new(&folder).exists() {
+            eprintln!("Error: Directory '{folder}' already exists");
+            println!(
+                "Hint: you can scaffold a tuono project within an existing folder with 'cd {folder} && tuono new .'"
+            );
+            std::process::exit(1);
+        }
+        create_dir(&folder).unwrap();
+    }
+
+    let folder_name = PathBuf::from(&folder);
+    let current_dir = env::current_dir().expect("Failed to get current working directory");
+
+    let folder_path = current_dir.join(folder_name);
+
+    create_directories(&new_project_files, &folder_path, &template)
+        .unwrap_or_else(|err| exit_with_error(&format!("Failed to create directories: {}", err)));
+
+    for GithubFile {
+        element_type, path, ..
+    } in new_project_files.iter()
+    {
+        if let GithubFileType::Blob = element_type {
+            let url =
+                generate_raw_content_url(select_head, cli_version, path, &github_raw_base_url);
+
+            let file_content = client
+                .get(url)
+                .send()
+                .map_err(|_| exit_with_error("Failed to call the folder github API"))
+                .and_then(|response| {
+                    response
+                        .text()
+                        .map_err(|_| exit_with_error("Failed to parse the repo structure"))
+                })
+                .unwrap();
+
+            let path = PathBuf::from(&path.replace(&format!("examples/{template}/"), ""));
+
+            let file_path = folder_path.join(&path);
+
+            if let Err(err) = create_file(file_path, file_content) {
+                exit_with_error(&format!("Failed to create file: {err}"));
+            }
+        }
+    }
+
+    update_package_json_version(&folder_path).expect("Failed to update package.json version");
+    update_cargo_toml_version(&folder_path).expect("Failed to update Cargo.toml version");
+    outro(folder);
+}
+
+fn generate_raw_content_url(
+    select_head: Option<bool>,
+    cli_version: &str,
+    path: &String,
+    url: &str,
+) -> String {
+    let tag = if select_head.unwrap_or(false) {
+        "/main"
+    } else {
+        &format!("/tuono-labs/tuono/v{cli_version}")
+    };
+    format!("{url}{tag}/{path}")
+}
+
+fn generate_tree_url(
+    select_head: Option<bool>,
+    client: &Client,
+    cli_version: &str,
+    url: &str,
+) -> String {
+    if select_head.unwrap_or(false) {
+        format!("{url}/repos/tuono-labs/tuono/git/trees/main?recursive=1")
+    } else {
+        // This string does not include the "v" version prefix
+        let res_tag = client
+            .get(format!(
+                "{url}/repos/tuono-labs/tuono/git/ref/tags/v{cli_version}"
+            ))
+            .send()
+            .unwrap_or_else(|_| {
+                exit_with_error("Failed to call the tag github API for v{cli_version}")
+            })
+            .json::<GithubTagResponse>()
+            .unwrap_or_else(|_| exit_with_error("Failed to parse the tag response"));
+
+        format!(
+            "{url}/repos/tuono-labs/tuono/git/trees/{}?recursive=1",
+            res_tag.object.sha
+        )
+    }
+}
+
+fn create_directories(
+    new_project_files: &[&GithubFile],
+    folder_path: &Path,
+    template: &String,
+) -> io::Result<()> {
+    for GithubFile {
+        element_type, path, ..
+    } in new_project_files.iter()
+    {
+        if let GithubFileType::Tree = element_type {
+            let path = PathBuf::from(&path.replace(&format!("examples/{template}/"), ""));
+
+            let dir_path = folder_path.join(&path);
+            if let Err(e) = create_dir(&dir_path) {
+                eprintln!("Failed to create directory {}: {}", dir_path.display(), e);
+                std::process::exit(1);
+            }
+        }
+    }
+    Ok(())
+}
+fn update_package_json_version(folder_path: &Path) -> io::Result<()> {
+    let v = crate_version!();
+    let package_json_path = folder_path.join(PathBuf::from("package.json"));
+    let package_json = fs::read_to_string(&package_json_path)
+        .unwrap_or_else(|err| exit_with_error(&format!("Failed to read package.json: {}", err)));
+    let package_json = package_json.replace("link:../../packages/tuono", v);
+
+    let mut file = OpenOptions::new()
+        .write(true)
+        .truncate(true)
+        .open(package_json_path)
+        .unwrap_or_else(|err| exit_with_error(&format!("Failed to open package.json: {}", err)));
+
+    file.write_all(package_json.as_bytes())
+        .unwrap_or_else(|err| {
+            exit_with_error(&format!("Failed to write to package.json: {}", err))
+        });
+
+    Ok(())
+}
+
+fn update_cargo_toml_version(folder_path: &Path) -> io::Result<()> {
+    let v = crate_version!();
+    let cargo_toml_path = folder_path.join(PathBuf::from("Cargo.toml"));
+    let cargo_toml = fs::read_to_string(&cargo_toml_path)
+        .unwrap_or_else(|err| exit_with_error(&format!("Failed to read Cargo.toml: {}", err)));
+    let cargo_toml = cargo_toml.replace(
+        "{ path = \"../../crates/tuono_lib/\" }",
+        &format!("\"{v}\""),
+    );
+
+    let mut file = OpenOptions::new()
+        .write(true)
+        .truncate(true)
+        .open(cargo_toml_path)
+        .unwrap_or_else(|err| exit_with_error(&format!("Failed to open Cargo.toml: {}", err)));
+
+    file.write_all(cargo_toml.as_bytes())
+        .unwrap_or_else(|err| exit_with_error(&format!("Failed to write to Cargo.toml: {}", err)));
+
+    Ok(())
+}
+
+fn outro(folder_name: String) {
+    println!("Success! 🎉");
+
+    if folder_name != "." {
+        println!("\nGo to the project directory:");
+        println!("cd {folder_name}/");
+    }
+
+    println!("\nInstall the dependencies:");
+    println!("npm install");
+
+    println!("\nRun the local environment:");
+    println!("tuono dev");
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn generate_valid_content_url_from_head() {
+        let expected = format!(
+            "{}/{}/{}",
+            "http://localhost:3000", "main", "examples/tuono-app"
+        );
+        let generated = generate_raw_content_url(
+            Some(true),
+            crate_version!(),
+            &String::from("examples/tuono-app"),
+            "http://localhost:3000",
+        );
+        assert_eq!(expected, generated)
+    }
+
+    #[test]
+    fn generate_valid_content_url_from_cli_version() {
+        let expected = format!(
+            "{}/{}/{}",
+            "http://localhost:3000",
+            &format!("tuono-labs/tuono/v{}", crate_version!()),
+            "examples/tuono-app"
+        );
+        let generated = generate_raw_content_url(
+            Some(false),
+            crate_version!(),
+            &String::from("examples/tuono-app"),
+            "http://localhost:3000",
+        );
+        assert_eq!(expected, generated)
+    }
+}

crates/tuono/src/lib.rs

@@ -1,66 +1,11 @@
-use clap::{Parser, Subcommand};
-use std::process::Command;
+//! ## Tuono
+//! Tuono is a full-stack web framework for building React applications using Rust as the backend with a strong focus on usability and performance.
+//!
+//! You can find the full documentation at [tuono.dev](https://tuono.dev/)
 
+mod app;
+pub mod cli;
+mod commands;
+mod mode;
+mod route;
 mod source_builder;
-use source_builder::{bundle_axum_source, create_client_entry_files};
-
-use crate::source_builder::{check_tuono_folder, Mode};
-
-mod scaffold_project;
-mod watch;
-
-#[derive(Subcommand, Debug)]
-enum Actions {
-    /// Start the development environment
-    Dev,
-    /// Build the production assets
-    Build,
-    /// Scaffold a new project
-    New {
-        /// The folder in which load the project. Default is the current directory.
-        folder_name: Option<String>,
-        /// The template to use to scaffold the project. The template should match one of the tuono
-        /// examples
-        #[arg(short, long)]
-        template: Option<String>,
-    },
-}
-
-#[derive(Parser, Debug)]
-#[command(version, about = "The react/rust fullstack framework")]
-struct Args {
-    #[command(subcommand)]
-    action: Actions,
-}
-
-fn init_tuono_folder(mode: Mode) -> std::io::Result<()> {
-    check_tuono_folder()?;
-    bundle_axum_source(mode)?;
-    create_client_entry_files()?;
-
-    Ok(())
-}
-
-pub fn cli() -> std::io::Result<()> {
-    let args = Args::parse();
-
-    match args.action {
-        Actions::Dev => {
-            init_tuono_folder(Mode::Dev)?;
-            watch::watch().unwrap();
-        }
-        Actions::Build => {
-            init_tuono_folder(Mode::Prod)?;
-            let mut vite_build = Command::new("./node_modules/.bin/tuono-build-prod");
-            let _ = &vite_build.output()?;
-        }
-        Actions::New {
-            folder_name,
-            template,
-        } => {
-            scaffold_project::create_new_project(folder_name, template);
-        }
-    }
-
-    Ok(())
-}

crates/tuono/src/main.rs

@@ -1,5 +1,18 @@
-use tuono::cli;
+use tracing::error;
+use tracing_subscriber::EnvFilter;
+use tuono::cli::app;
 
 fn main() {
-    cli().unwrap();
+    tracing_subscriber::fmt()
+        // Time not needed since the execution is synchronous
+        .without_time()
+        .with_env_filter(EnvFilter::from_default_env())
+        .init();
+
+    if let Err(e) = app() {
+        // Generic error.
+        // Recoverable errors should be managed locally
+        error!("Failed to run the tuono CLI: {}", e);
+        std::process::exit(1);
+    }
 }

crates/tuono/src/mode.rs

@@ -0,0 +1,28 @@
+#[derive(PartialEq, Eq, Debug, Clone)]
+pub enum Mode {
+    Prod,
+    Dev,
+}
+
+impl Mode {
+    pub fn as_str<'a>(&self) -> &'a str {
+        if *self == Mode::Dev {
+            return "Mode::Dev";
+        }
+        "Mode::Prod"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[test]
+    fn should_correctly_print_the_mode_as_str() {
+        let dev = Mode::Dev.as_str();
+        let prod = Mode::Prod.as_str();
+        assert_eq!(dev, "Mode::Dev");
+        assert_eq!(prod, "Mode::Prod");
+    }
+}

crates/tuono/src/route.rs

@@ -0,0 +1,353 @@
+use fs_extra::dir::create_all;
+use http::Method;
+use regex::Regex;
+use reqwest::Url;
+use reqwest::blocking::Client;
+use std::fs::File;
+use std::io;
+use std::path::PathBuf;
+use std::str::FromStr;
+use tracing::trace;
+
+fn has_dynamic_path(route: &str) -> bool {
+    let regex = Regex::new(r"\[(.*?)\]").expect("Failed to create the regex");
+    regex.is_match(route)
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct AxumInfo {
+    // Path for importing the module
+    pub module_import: String,
+    // path for the the axum router
+    pub axum_route: String,
+}
+
+impl AxumInfo {
+    pub fn new(route: &Route) -> Self {
+        // Remove first slash
+        let mut module = route.path.chars();
+        module.next();
+
+        let axum_route = if route.path.ends_with("/index") {
+            route.path.replace("/index", "")
+        } else {
+            route.path.clone()
+        };
+
+        let module_import = module
+            .as_str()
+            .to_string()
+            .replace('/', "_")
+            .replace('.', "_dot_")
+            .replace('-', "_hyphen_")
+            .to_lowercase();
+
+        if axum_route.is_empty() {
+            return AxumInfo {
+                module_import,
+                axum_route: "/".to_string(),
+            };
+        }
+
+        if route.is_dynamic {
+            let dyn_re = Regex::new(r"\[(.*?)\]").expect("Failed to create dyn regex");
+            let catch_all_re =
+                Regex::new(r"\{\.\.\.(.*?)\}").expect("Failed to create catch all regex");
+
+            let dyn_result = dyn_re.replace_all(&axum_route, |caps: &regex::Captures| {
+                format!("{{{}}}", &caps[1])
+            });
+
+            let axum_route = catch_all_re
+                .replace_all(&dyn_result, |caps: &regex::Captures| {
+                    format!("{{*{}}}", &caps[1])
+                })
+                .to_string();
+
+            return AxumInfo {
+                module_import: module
+                    .as_str()
+                    .to_string()
+                    .replace('/', "_")
+                    .replace('-', "_hyphen_")
+                    .replace('[', "dyn_")
+                    .replace("...", "catch_all_")
+                    .replace(']', ""),
+                axum_route,
+            };
+        }
+
+        AxumInfo {
+            module_import,
+            axum_route,
+        }
+    }
+}
+
+// TODO: to be extended with common scenarios
+const NO_HTML_EXTENSIONS: [&str; 2] = ["xml", "txt"];
+
+// TODO: Refine this function to catch
+// if the methods are commented.
+fn read_http_methods_from_file(path: &String) -> Vec<Method> {
+    let regex = Regex::new(r"tuono_lib::api\((.*?)\)]").expect("Failed to create API regex");
+
+    let file = fs_extra::file::read_to_string(path).expect("Failed to read API file");
+
+    regex
+        .find_iter(&file)
+        .map(|proc_macro| {
+            let http_method = proc_macro
+                .as_str()
+                // Extract just the element surrounded by the phrantesist.
+                .replace("tuono_lib::api(", "")
+                .replace(")]", "");
+            Method::from_str(http_method.as_str()).unwrap_or(Method::GET)
+        })
+        .collect::<Vec<Method>>()
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct ApiData {
+    pub methods: Vec<Method>,
+}
+
+impl ApiData {
+    pub fn new(path: &String) -> Option<Self> {
+        if !path.starts_with("/api/") {
+            return None;
+        }
+
+        let base_path = std::env::current_dir().expect("Failed to get the base_path");
+
+        let file_path = base_path
+            .join(format!("src/routes{path}.rs"))
+            .to_str()
+            .unwrap()
+            .to_string();
+        let methods = read_http_methods_from_file(&file_path);
+
+        Some(ApiData { methods })
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct Route {
+    path: String,
+    pub is_dynamic: bool,
+    pub axum_info: Option<AxumInfo>,
+    pub api_data: Option<ApiData>,
+}
+
+impl Route {
+    pub fn new(cleaned_path: String) -> Self {
+        Route {
+            path: cleaned_path.clone(),
+            axum_info: None,
+            is_dynamic: has_dynamic_path(&cleaned_path),
+            api_data: ApiData::new(&cleaned_path),
+        }
+    }
+
+    pub fn is_api(&self) -> bool {
+        self.api_data.is_some()
+    }
+
+    pub fn update_axum_info(&mut self) {
+        self.axum_info = Some(AxumInfo::new(self))
+    }
+
+    pub fn save_ssg_file(&self, reqwest: &Client) -> Result<(), String> {
+        if self.is_api() {
+            return Ok(());
+        }
+
+        let path = &self.path.replace("index", "");
+
+        let url = format!("http://localhost:3000{path}");
+
+        trace!("Requesting the page: {}", url);
+        let mut response = match reqwest.get(format!("http://localhost:3000{path}")).send() {
+            Ok(response) => response,
+            Err(_) => return Err(format!("Failed to get the response: {}", url)),
+        };
+
+        let file_path = self.output_file_path();
+
+        let parent_dir = match file_path.parent() {
+            Some(parent_dir) => parent_dir,
+            None => {
+                return Err(format!(
+                    "Failed to get the parent directory {:?}",
+                    file_path
+                ));
+            }
+        };
+
+        if !parent_dir.is_dir() {
+            if let Err(err) = create_all(parent_dir, false) {
+                return Err(format!(
+                    "Failed to create the parent directory {:?}\nError: {err}",
+                    parent_dir
+                ));
+            }
+        }
+
+        trace!("Saving the HTML file: {:?}", file_path);
+
+        let mut file = match File::create(&file_path) {
+            Ok(file) => file,
+            Err(_) => return Err(format!("Failed to create the file: {:?}", file_path)),
+        };
+
+        if io::copy(&mut response, &mut file).is_err() {
+            return Err(format!("Failed to write the file: {:?}", file_path));
+        }
+
+        // Saving also the server response
+        if self.axum_info.is_some() {
+            trace!("The route is an axum route, saving the JSON file");
+
+            let data_file_path = PathBuf::from(&format!("out/static/__tuono/data{path}.json"));
+
+            let data_parent_dir = match data_file_path.parent() {
+                Some(parent_dir) => parent_dir,
+                None => {
+                    return Err(format!(
+                        "Failed to get the parent directory {:?}",
+                        data_file_path
+                    ));
+                }
+            };
+
+            if !data_parent_dir.is_dir() {
+                if let Err(err) = create_all(data_parent_dir, false) {
+                    return Err(format!(
+                        "Failed to create the parent directory {:?}\n Error: {err}",
+                        data_parent_dir
+                    ));
+                }
+            }
+
+            let base = Url::parse("http://localhost:3000/__tuono/data").unwrap();
+
+            let path = if path == "/" { "" } else { path };
+
+            let pathname = &format!("/__tuono/data{path}");
+
+            let url = base
+                .join(pathname)
+                .expect("Failed to build the reqwest URL");
+
+            trace!("Requesting the JSON file: {}", url);
+
+            let mut response = match reqwest.get(url.clone()).send() {
+                Ok(response) => {
+                    trace!("Successfully got the response for: {url}");
+                    response
+                }
+                Err(_) => return Err(format!("Failed to get the response: {url}")),
+            };
+
+            let mut data_file = match File::create(&data_file_path) {
+                Ok(file) => file,
+                Err(_) => {
+                    return Err(format!(
+                        "Failed to create the JSON file: {:?}",
+                        data_file_path
+                    ));
+                }
+            };
+
+            if io::copy(&mut response, &mut data_file).is_err() {
+                return Err("Failed to write the JSON file".to_string());
+            }
+        }
+
+        Ok(())
+    }
+
+    fn output_file_path(&self) -> PathBuf {
+        let cleaned_path = self.path.replace("index", "");
+
+        if NO_HTML_EXTENSIONS
+            .iter()
+            .any(|extension| self.path.ends_with(extension))
+        {
+            return PathBuf::from(format!("out/static{}", cleaned_path));
+        }
+
+        PathBuf::from(format!("out/static{}/index.html", cleaned_path))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[test]
+    fn should_find_dynamic_paths() {
+        let routes = [
+            ("/home/user/Documents/tuono/src/routes/about.rs", false),
+            ("/home/user/Documents/tuono/src/routes/index.rs", false),
+            (
+                "/home/user/Documents/tuono/src/routes/posts/index.rs",
+                false,
+            ),
+            (
+                "/home/user/Documents/tuono/src/routes/posts/[post].rs",
+                true,
+            ),
+        ];
+
+        routes
+            .into_iter()
+            .for_each(|route| assert_eq!(has_dynamic_path(route.0), route.1));
+    }
+
+    #[test]
+    fn should_allow_index_in_route_name() {
+        let index_route = AxumInfo::new(&Route::new("/index".to_string()));
+        let index_page_route = AxumInfo::new(&Route::new("/index-page".to_string()));
+
+        assert_eq!(index_route.axum_route, "/");
+        assert_eq!(index_route.module_import, "index");
+
+        assert_eq!(index_page_route.axum_route, "/index-page");
+        assert_eq!(index_page_route.module_import, "index_hyphen_page");
+    }
+
+    #[test]
+    fn should_correctly_create_the_axum_infos() {
+        let info = AxumInfo::new(&Route::new("/index".to_string()));
+
+        assert_eq!(info.axum_route, "/");
+        assert_eq!(info.module_import, "index");
+
+        let dyn_info = AxumInfo::new(&Route::new("/[posts]".to_string()));
+
+        assert_eq!(dyn_info.axum_route, "/{posts}");
+        assert_eq!(dyn_info.module_import, "dyn_posts");
+    }
+
+    #[test]
+    fn should_define_the_correct_html_build_path() {
+        let routes = [
+            ("/index", "out/static/index.html"),
+            ("/documentation", "out/static/documentation/index.html"),
+            ("/sitemap.xml", "out/static/sitemap.xml"),
+            ("/robot.txt", "out/static/robot.txt"),
+            (
+                "/documentation/routing",
+                "out/static/documentation/routing/index.html",
+            ),
+        ];
+
+        for (path, html) in routes {
+            let route = Route::new(path.to_string());
+
+            assert_eq!(route.output_file_path(), PathBuf::from(html))
+        }
+    }
+}

crates/tuono/src/scaffold_project.rs

@@ -1,172 +0,0 @@
-use clap::crate_version;
-use reqwest::blocking;
-use serde::Deserialize;
-use std::env;
-use std::fs::{self, create_dir, File, OpenOptions};
-use std::io::{self, prelude::*};
-use std::path::{Path, PathBuf};
-
-const GITHUB_TUONO_REPO_URL: &str =
-    "https://api.github.com/repos/Valerioageno/tuono/git/trees/main?recursive=1";
-
-const GITHUB_RAW_CONTENT_URL: &str = "https://raw.githubusercontent.com/Valerioageno/tuono/main/";
-
-#[derive(Deserialize, Debug)]
-enum GithubFileType {
-    #[serde(rename = "blob")]
-    Blob,
-    #[serde(rename = "tree")]
-    Tree,
-}
-
-#[derive(Deserialize, Debug)]
-struct GithubResponse<T> {
-    tree: Vec<T>,
-}
-
-#[derive(Deserialize, Debug)]
-struct GithubFile {
-    path: String,
-    #[serde(rename(deserialize = "type"))]
-    element_type: GithubFileType,
-}
-
-fn create_file(path: PathBuf, content: String) -> std::io::Result<()> {
-    let mut file = File::create(path)?;
-    let _ = file.write_all(content.as_bytes());
-
-    Ok(())
-}
-
-pub fn create_new_project(folder_name: Option<String>, template: Option<String>) {
-    let folder = folder_name.unwrap_or(".".to_string());
-
-    // In case of missing select the tuono example
-    let template = template.unwrap_or("tuono".to_string());
-
-    let client = blocking::Client::builder()
-        .user_agent("")
-        .build()
-        .expect("Failed to build reqwest client");
-
-    let res = client
-        .get(GITHUB_TUONO_REPO_URL)
-        .send()
-        .expect("Failed to call the folder github API")
-        .json::<GithubResponse<GithubFile>>()
-        .expect("Failed to parse the repo structure");
-
-    let new_project_files = res
-        .tree
-        .iter()
-        .filter(|GithubFile { path, .. }| path.starts_with(&format!("examples/{template}/")))
-        .collect::<Vec<&GithubFile>>();
-
-    if new_project_files.is_empty() {
-        println!("Template not found: {template}");
-        return;
-    }
-
-    if folder != "." {
-        create_dir(&folder).unwrap();
-    }
-
-    let folder_name = PathBuf::from(&folder);
-    let current_dir = env::current_dir().expect("Failed to get current working directory");
-
-    let folder_path = current_dir.join(folder_name);
-
-    create_directories(&new_project_files, &folder_path, &template)
-        .expect("Failed to create directories");
-
-    for GithubFile {
-        element_type, path, ..
-    } in new_project_files.iter()
-    {
-        if let GithubFileType::Blob = element_type {
-            let file_content = client
-                .get(format!("{GITHUB_RAW_CONTENT_URL}{path}"))
-                .send()
-                .expect("Failed to call the folder github API")
-                .text()
-                .expect("Failed to parse the repo structure");
-
-            let path = PathBuf::from(&path.replace(&format!("examples/{template}/"), ""));
-
-            let file_path = folder_path.join(&path);
-
-            create_file(file_path, file_content).expect("failed to create file");
-        }
-    }
-
-    update_package_json_version(&folder_path).expect("Failed to update package.json version");
-    update_cargo_toml_version(&folder_path).expect("Failed to update Cargo.toml version");
-    outro(folder);
-}
-
-fn create_directories(
-    new_project_files: &[&GithubFile],
-    folder_path: &Path,
-    template: &String,
-) -> io::Result<()> {
-    for GithubFile {
-        element_type, path, ..
-    } in new_project_files.iter()
-    {
-        if let GithubFileType::Tree = element_type {
-            let path = PathBuf::from(&path.replace(&format!("examples/{template}/"), ""));
-
-            let dir_path = folder_path.join(&path);
-            create_dir(&dir_path).unwrap();
-        }
-    }
-    Ok(())
-}
-
-fn update_package_json_version(folder_path: &Path) -> io::Result<()> {
-    let v = crate_version!();
-    let package_json_path = folder_path.join(PathBuf::from("package.json"));
-    let package_json = fs::read_to_string(&package_json_path)?;
-    let package_json = package_json.replace("link:../../packages/tuono", v);
-
-    let mut file = OpenOptions::new()
-        .write(true)
-        .truncate(true)
-        .open(package_json_path)?;
-
-    file.write_all(package_json.as_bytes())?;
-
-    Ok(())
-}
-
-fn update_cargo_toml_version(folder_path: &Path) -> io::Result<()> {
-    let v = crate_version!();
-    let cargo_toml_path = folder_path.join(PathBuf::from("Cargo.toml"));
-    let cargo_toml = fs::read_to_string(&cargo_toml_path)?;
-    let cargo_toml =
-        cargo_toml.replace("{ path = \"../../crates/tuono_lib/\"}", &format!("\"{v}\""));
-
-    let mut file = OpenOptions::new()
-        .write(true)
-        .truncate(true)
-        .open(cargo_toml_path)?;
-
-    file.write_all(cargo_toml.as_bytes())?;
-
-    Ok(())
-}
-
-fn outro(folder_name: String) {
-    println!("Success! 🎉");
-
-    if folder_name != "." {
-        println!("\nGo to the project directory:");
-        println!("cd {folder_name}/");
-    }
-
-    println!("\nInstall the dependencies:");
-    println!("pnpm install");
-
-    println!("\nRun the local environment:");
-    println!("tuono dev");
-}

crates/tuono/src/source_builder.rs

@@ -1,291 +1,236 @@
-use glob::glob;
-use glob::GlobError;
-use regex::Regex;
-use std::collections::HashMap;
 use std::fs;
 use std::io;
 use std::io::prelude::*;
 use std::path::Path;
 use std::path::PathBuf;
 
-#[derive(PartialEq, Eq)]
-pub enum Mode {
-    Prod,
-    Dev,
-}
+use clap::crate_version;
+use tracing::error;
 
-impl Mode {
-    pub fn as_str<'a>(&self) -> &'a str {
-        if *self == Mode::Dev {
-            return "Mode::Dev";
-        }
-        "Mode::Prod"
-    }
-}
+use crate::app::App;
+use crate::mode::Mode;
+use crate::route::AxumInfo;
+use crate::route::Route;
 
-pub const SERVER_ENTRY_DATA: &str = "// File automatically generated by tuono
-// Do not manually update this file
-import { routeTree } from './routeTree.gen'
-import { serverSideRendering } from 'tuono/ssr'
+#[cfg(not(target_os = "windows"))]
+const FALLBACK_HTML: &str = include_str!("../templates/fallback.html");
+#[cfg(not(target_os = "windows"))]
+const SERVER_ENTRY_DATA: &str = include_str!("../templates/server.ts");
+#[cfg(not(target_os = "windows"))]
+const CLIENT_ENTRY_DATA: &str = include_str!("../templates/client.ts");
+#[cfg(not(target_os = "windows"))]
+const AXUM_ENTRY_POINT: &str = include_str!("../templates/server.rs");
 
-export const renderFn = serverSideRendering(routeTree)
-";
+#[cfg(not(target_os = "windows"))]
+const MAIN_FILE_PATH: &str = "./.tuono/main.rs";
 
-pub const CLIENT_ENTRY_DATA: &str = "// File automatically generated by tuono
-// Do not manually update this file
-import 'vite/modulepreload-polyfill'
-import { hydrate } from 'tuono/hydration'
-import '../src/styles/global.css'
+#[cfg(not(target_os = "windows"))]
+const FALLBACK_HTML_PATH: &str = "./.tuono/index.html";
 
-// Import the generated route tree
-import { routeTree } from './routeTree.gen'
-
-hydrate(routeTree)
-";
-
-pub const AXUM_ENTRY_POINT: &str = r##"
-// File automatically generated
-// Do not manually change it
-
-use axum::extract::{Path, Request};
-use axum::response::Html;
-use axum::{routing::get, Router};
-use tower_http::services::ServeDir;
-use std::collections::HashMap;
-use tuono_lib::{ssr, Ssr, Mode, GLOBAL_MODE, manifest::load_manifest};
-use reqwest::Client;
-
-const MODE: Mode = /*MODE*/;
-
-// MODULE_IMPORTS
-
-#[tokio::main]
-async fn main() {
-    Ssr::create_platform();
-
-    let fetch = Client::new();
-
-    GLOBAL_MODE.set(MODE).unwrap();
-
-    if MODE == Mode::Prod {
-        load_manifest()
-    }
-
-    let app = Router::new()
-        // ROUTE_BUILDER
-        .fallback_service(
-            ServeDir::new("public"))
-        .fallback_service(ServeDir::new("out/client")
-            .fallback(get(catch_all)))
-        .with_state(fetch);
-
-    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
-
-    if MODE == Mode::Dev {
-        println!("\nDevelopment app ready at http://localhost:3000/");
-    } else {
-        println!("\nProduction app ready at http://localhost:3000/");
-    }
-    axum::serve(listener, app).await.unwrap();
-}
-
-async fn catch_all(Path(params): Path<HashMap<String, String>>, request: Request) -> Html<String> {
-    let pathname = &request.uri();
-    let headers = &request.headers();
-
-    let req = tuono_lib::Request::new(pathname, headers, params);
-
-
-    // TODO: remove unwrap
-    let payload = tuono_lib::Payload::new(&req, &"")
-        .client_payload()
-        .unwrap();
-
-    let result = ssr::Js::SSR.with(|ssr| ssr.borrow_mut().render_to_string(Some(&payload)));
-
-    match result {
-        Ok(html) => Html(html),
-        _ => Html("500 internal server error".to_string()),
-    }
-}
-"##;
-
-const ROOT_FOLDER: &str = "src/routes";
+const ROUTE_FOLDER: &str = "src/routes";
 const DEV_FOLDER: &str = ".tuono";
 
-#[derive(Debug, PartialEq, Eq)]
-struct Route {
-    /// Every module import is the path with a _ instead of /
-    pub module_import: String,
-    pub axum_route: String,
+#[cfg(target_os = "windows")]
+const FALLBACK_HTML: &str = include_str!("..\\templates\\fallback.html");
+#[cfg(target_os = "windows")]
+const SERVER_ENTRY_DATA: &str = include_str!("..\\templates\\server.ts");
+#[cfg(target_os = "windows")]
+const CLIENT_ENTRY_DATA: &str = include_str!("..\\templates\\client.ts");
+#[cfg(target_os = "windows")]
+const AXUM_ENTRY_POINT: &str = include_str!("..\\templates\\server.rs");
+
+#[cfg(target_os = "windows")]
+const MAIN_FILE_PATH: &str = ".\\.tuono\\main.rs";
+
+#[cfg(target_os = "windows")]
+const FALLBACK_HTML_PATH: &str = ".\\.tuono\\index.html";
+
+// Use this function to instruct the users on how to
+// fix their setup to make tuono work
+fn recoverable_error(message: &str) -> ! {
+    error!("{}", message);
+    std::process::exit(1);
 }
 
-fn has_dynamic_path(route: &str) -> bool {
-    let regex = Regex::new(r"\[(.*?)\]").expect("Failed to create the regex");
-    regex.is_match(route)
-}
-
-impl Route {
-    pub fn new(path: &str) -> Self {
-        let route_name = path.replace(".rs", "");
-        // Remove first slash
-        let mut module = route_name.as_str().chars();
-        module.next();
-
-        let axum_route = path.replace("/index.rs", "").replace(".rs", "");
-
-        if axum_route.is_empty() {
-            return Route {
-                module_import: module.as_str().to_string().replace('/', "_"),
-                axum_route: "/".to_string(),
-            };
-        }
-
-        if has_dynamic_path(&route_name) {
-            return Route {
-                module_import: module
-                    .as_str()
-                    .to_string()
-                    .replace('/', "_")
-                    .replace('[', "dyn_")
-                    .replace(']', ""),
-                axum_route: axum_route.replace('[', ":").replace(']', ""),
-            };
-        }
-
-        Route {
-            module_import: module.as_str().to_string().replace('/', "_"),
-            axum_route,
-        }
-    }
-}
-
-struct SourceBuilder {
-    route_map: HashMap<PathBuf, Route>,
+// Struct to build the source code
+// on both "dev" and "build" commands
+#[derive(Clone, Debug)]
+pub struct SourceBuilder {
+    pub app: App,
+    mode: Mode,
     base_path: PathBuf,
 }
 
 impl SourceBuilder {
-    pub fn new() -> Self {
-        let base_path = std::env::current_dir().unwrap();
+    pub fn new(mode: Mode) -> io::Result<Self> {
+        if !PathBuf::from("tuono.config.ts").exists() {
+            recoverable_error("Cannot find tuono.config.ts - is this a tuono project?");
+        }
 
-        SourceBuilder {
-            route_map: HashMap::new(),
+        let dev_folder = Path::new(DEV_FOLDER);
+        if !&dev_folder.is_dir() {
+            fs::create_dir(dev_folder)?;
+        }
+
+        let app = App::new();
+
+        let base_path = std::env::current_dir()?;
+
+        Ok(Self {
+            app,
+            mode,
             base_path,
+        })
+    }
+
+    // Build the source code needed for both build and dev
+    pub fn base_build(&mut self) -> io::Result<()> {
+        let Self { mode, .. } = &self;
+
+        self.refresh_axum_source()?;
+        let dev_folder = Path::new(DEV_FOLDER);
+        self.create_file(dev_folder.join("server-main.tsx"), SERVER_ENTRY_DATA)?;
+        self.create_file(dev_folder.join("client-main.tsx"), CLIENT_ENTRY_DATA)?;
+
+        if mode == &Mode::Dev {
+            self.app.build_tuono_config()?;
+            let fallback_html = self.build_html_fallback();
+            self.create_file(PathBuf::from(FALLBACK_HTML_PATH), &fallback_html)?;
+        }
+
+        Ok(())
+    }
+
+    fn generate_axum_source(&self) -> String {
+        let Self { app, mode, .. } = &self;
+
+        let src = AXUM_ENTRY_POINT
+            .replace("\r", "")
+            .replace("// ROUTE_BUILDER\n", &self.create_routes_declaration())
+            .replace("// MODULE_IMPORTS\n", &self.create_modules_declaration())
+            .replace("/*VERSION*/", crate_version!())
+            .replace("/*MODE*/", mode.as_str())
+            .replace(
+                "//MAIN_FILE_IMPORT//",
+                if app.has_app_state {
+                    r#"#[path="../src/app.rs"]
+                    mod tuono_main_state;
+                    "#
+                } else {
+                    ""
+                },
+            )
+            .replace(
+                "//MAIN_FILE_DEFINITION//",
+                if app.has_app_state {
+                    "let user_custom_state = tuono_main_state::main();"
+                } else {
+                    ""
+                },
+            )
+            .replace(
+                "//MAIN_FILE_USAGE//",
+                if app.has_app_state {
+                    ".with_state(user_custom_state)"
+                } else {
+                    ""
+                },
+            );
+
+        let mut import_http_handler = String::new();
+
+        let used_http_methods = app.get_used_http_methods();
+
+        for method in used_http_methods.into_iter() {
+            let method = method.to_string().to_lowercase();
+            import_http_handler.push_str(&format!("use tuono_lib::axum::routing::{method};\n"))
+        }
+
+        src.replace("// AXUM_GET_ROUTE_HANDLER", &import_http_handler)
+    }
+
+    pub fn refresh_axum_source(&self) -> io::Result<()> {
+        let axum_source = self.generate_axum_source();
+
+        self.create_file(PathBuf::from(MAIN_FILE_PATH), &axum_source)?;
+
+        Ok(())
+    }
+
+    fn create_file(&self, path: PathBuf, content: &str) -> io::Result<()> {
+        let mut data_file = fs::File::create(self.base_path.join(path))?;
+
+        data_file.write_all(content.as_bytes())?;
+
+        Ok(())
+    }
+
+    fn create_routes_declaration(&self) -> String {
+        let routes = &self.app.route_map;
+        let mut route_declarations = String::from("// ROUTE_BUILDER\n");
+
+        for (_, route) in routes.iter() {
+            let Route { axum_info, .. } = &route;
+
+            if axum_info.is_some() {
+                let AxumInfo {
+                    axum_route,
+                    module_import,
+                } = axum_info.as_ref().unwrap();
+
+                if !route.is_api() {
+                    route_declarations.push_str(&format!(
+                        r#".route("{axum_route}", get({module_import}::tuono_internal_route))"#
+                    ));
+
+                    route_declarations.push_str(&format!(
+                            r#".route("/__tuono/data{axum_route}", get({module_import}::tuono_internal_api))"#
+                    ));
+                } else {
+                    for method in route.api_data.as_ref().unwrap().methods.clone() {
+                        let method = method.to_string().to_lowercase();
+                        route_declarations.push_str(&format!(
+                                r#".route("{axum_route}", {method}({module_import}::{method}_tuono_internal_api))"#
+                        ));
+                    }
+                }
+            }
+        }
+
+        route_declarations
+    }
+
+    fn create_modules_declaration(&self) -> String {
+        let routes = &self.app.route_map;
+        let mut route_declarations = String::from("// MODULE_IMPORTS\n");
+
+        for (path, route) in routes.iter() {
+            if route.axum_info.is_some() {
+                let AxumInfo { module_import, .. } = route.axum_info.as_ref().unwrap();
+
+                route_declarations.push_str(&format!(
+                    r#"#[path="../{ROUTE_FOLDER}{path}.rs"]
+                    mod {module_import};
+                    "#
+                ))
+            }
+        }
+
+        route_declarations
+    }
+
+    fn build_html_fallback(&self) -> String {
+        if let Some(config) = &self.app.config.as_ref() {
+            if let Some(origin) = &config.server.origin {
+                FALLBACK_HTML.replace("[BASE_URL]", origin)
+            } else {
+                let url = format!("http://{}:{}", config.server.host, config.server.port);
+                FALLBACK_HTML.replace("[BASE_URL]", url.as_str())
+            }
+        } else {
+            "".to_string()
         }
     }
-
-    fn collect_routes(&mut self) {
-        glob(self.base_path.join("src/routes/**/*.rs").to_str().unwrap())
-            .unwrap()
-            .for_each(|entry| self.collect_route(entry))
-    }
-
-    fn collect_route(&mut self, path_buf: Result<PathBuf, GlobError>) {
-        let entry = path_buf.unwrap();
-        let base_path_str = self.base_path.to_str().unwrap();
-        let path = entry
-            .to_str()
-            .unwrap()
-            .replace(&format!("{base_path_str}/src/routes"), "");
-
-        let route = Route::new(&path);
-
-        self.route_map.insert(PathBuf::from(path), route);
-    }
-}
-
-fn create_main_file(base_path: &Path, bundled_file: &String) {
-    let mut data_file =
-        fs::File::create(base_path.join(".tuono/main.rs")).expect("creation failed");
-
-    data_file
-        .write_all(bundled_file.as_bytes())
-        .expect("write failed");
-}
-
-fn create_routes_declaration(routes: &HashMap<PathBuf, Route>) -> String {
-    let mut route_declarations = String::from("// ROUTE_BUILDER\n");
-
-    for (_, route) in routes.iter() {
-        let Route {
-            axum_route,
-            module_import,
-        } = &route;
-
-        route_declarations.push_str(&format!(
-            r#".route("{axum_route}", get({module_import}::route))"#
-        ));
-        route_declarations.push_str(&format!(
-            r#".route("/__tuono/data{axum_route}", get({module_import}::api))"#
-        ));
-    }
-
-    route_declarations
-}
-
-fn create_modules_declaration(routes: &HashMap<PathBuf, Route>) -> String {
-    let mut route_declarations = String::from("// MODULE_IMPORTS\n");
-
-    for (path, route) in routes.iter() {
-        let module_name = &route.module_import;
-        let path_str = path.to_str().unwrap();
-        route_declarations.push_str(&format!(
-            r#"#[path="../{ROOT_FOLDER}{path_str}"]
-mod {module_name};
-"#
-        ))
-    }
-
-    route_declarations
-}
-
-pub fn bundle_axum_source(mode: Mode) -> io::Result<()> {
-    let base_path = std::env::current_dir().unwrap();
-
-    let mut source_builder = SourceBuilder::new();
-
-    source_builder.collect_routes();
-
-    let bundled_file = generate_axum_source(&source_builder, mode);
-
-    create_main_file(&base_path, &bundled_file);
-
-    Ok(())
-}
-
-fn generate_axum_source(source_builder: &SourceBuilder, mode: Mode) -> String {
-    AXUM_ENTRY_POINT
-        .replace(
-            "// ROUTE_BUILDER\n",
-            &create_routes_declaration(&source_builder.route_map),
-        )
-        .replace(
-            "// MODULE_IMPORTS\n",
-            &create_modules_declaration(&source_builder.route_map),
-        )
-        .replace("/*MODE*/", mode.as_str())
-}
-
-pub fn check_tuono_folder() -> io::Result<()> {
-    let dev_folder = Path::new(DEV_FOLDER);
-    if !&dev_folder.is_dir() {
-        fs::create_dir(dev_folder)?;
-    }
-
-    Ok(())
-}
-
-pub fn create_client_entry_files() -> io::Result<()> {
-    let dev_folder = Path::new(DEV_FOLDER);
-
-    let mut server_entry = fs::File::create(dev_folder.join("server-main.tsx"))?;
-    let mut client_entry = fs::File::create(dev_folder.join("client-main.tsx"))?;
-
-    server_entry.write_all(SERVER_ENTRY_DATA.as_bytes())?;
-    client_entry.write_all(CLIENT_ENTRY_DATA.as_bytes())?;
-
-    Ok(())
 }
 
 #[cfg(test)]
@@ -293,115 +238,74 @@ mod tests {
 
     use super::*;
 
-    #[test]
-    fn should_find_dynamic_paths() {
-        let routes = [
-            ("/home/user/Documents/tuono/src/routes/about.rs", false),
-            ("/home/user/Documents/tuono/src/routes/index.rs", false),
-            (
-                "/home/user/Documents/tuono/src/routes/posts/index.rs",
-                false,
-            ),
-            (
-                "/home/user/Documents/tuono/src/routes/posts/[post].rs",
-                true,
-            ),
-        ];
-
-        routes
-            .into_iter()
-            .for_each(|route| assert_eq!(has_dynamic_path(route.0), route.1));
-    }
-
-    #[test]
-    fn should_collect_routes() {
-        let mut source_builder = SourceBuilder::new();
-        source_builder.base_path = "/home/user/Documents/tuono".into();
-
-        let routes = [
-            "/home/user/Documents/tuono/src/routes/about.rs",
-            "/home/user/Documents/tuono/src/routes/index.rs",
-            "/home/user/Documents/tuono/src/routes/posts/index.rs",
-            "/home/user/Documents/tuono/src/routes/posts/[post].rs",
-        ];
-
-        routes
-            .into_iter()
-            .for_each(|route| source_builder.collect_route(Ok(PathBuf::from(route))));
-
-        let results = [
-            ("/index.rs", "index"),
-            ("/about.rs", "about"),
-            ("/posts/index.rs", "posts_index"),
-            ("/posts/[post].rs", "posts_dyn_post"),
-        ];
-
-        results.into_iter().for_each(|(path, module_import)| {
-            assert_eq!(
-                source_builder
-                    .route_map
-                    .get(&PathBuf::from(path))
-                    .unwrap()
-                    .module_import,
-                String::from(module_import)
-            )
-        })
-    }
-
-    #[test]
-    fn should_create_multi_level_axum_paths() {
-        let mut source_builder = SourceBuilder::new();
-        source_builder.base_path = "/home/user/Documents/tuono".into();
-
-        let routes = [
-            "/home/user/Documents/tuono/src/routes/about.rs",
-            "/home/user/Documents/tuono/src/routes/index.rs",
-            "/home/user/Documents/tuono/src/routes/posts/index.rs",
-            "/home/user/Documents/tuono/src/routes/posts/any-post.rs",
-            "/home/user/Documents/tuono/src/routes/posts/[post].rs",
-        ];
-
-        routes
-            .into_iter()
-            .for_each(|route| source_builder.collect_route(Ok(PathBuf::from(route))));
-
-        let results = [
-            ("/index.rs", "/"),
-            ("/about.rs", "/about"),
-            ("/posts/index.rs", "/posts"),
-            ("/posts/any-post.rs", "/posts/any-post"),
-            ("/posts/[post].rs", "/posts/:post"),
-        ];
-
-        results.into_iter().for_each(|(path, expected_path)| {
-            assert_eq!(
-                source_builder
-                    .route_map
-                    .get(&PathBuf::from(path))
-                    .unwrap()
-                    .axum_route,
-                String::from(expected_path)
-            )
-        })
-    }
-
     #[test]
     fn should_set_the_correct_mode() {
-        let source_builder = SourceBuilder::new();
+        let dev_bundle = SourceBuilder {
+            app: App::new(),
+            mode: Mode::Dev,
+            base_path: PathBuf::new(),
+        }
+        .generate_axum_source();
+
+        let prod_bundle = SourceBuilder {
+            app: App::new(),
+            mode: Mode::Prod,
+            base_path: PathBuf::new(),
+        }
+        .generate_axum_source();
 
-        let dev_bundle = generate_axum_source(&source_builder, Mode::Dev);
         assert!(dev_bundle.contains("const MODE: Mode = Mode::Dev;"));
-
-        let prod_bundle = generate_axum_source(&source_builder, Mode::Prod);
-
         assert!(prod_bundle.contains("const MODE: Mode = Mode::Prod;"));
     }
 
     #[test]
-    fn should_correctly_print_the_mode_as_str() {
-        let dev = Mode::Dev.as_str();
-        let prod = Mode::Prod.as_str();
-        assert_eq!(dev, "Mode::Dev");
-        assert_eq!(prod, "Mode::Prod");
+    fn should_not_load_the_axum_get_function() {
+        let dev_bundle = SourceBuilder {
+            app: App::new(),
+            mode: Mode::Dev,
+            base_path: PathBuf::new(),
+        }
+        .generate_axum_source();
+
+        assert!(!dev_bundle.contains("use tuono_lib::axum::routing::get;"));
+    }
+
+    #[test]
+    fn should_load_the_axum_get_function() {
+        let mut source_builder = SourceBuilder {
+            app: App::new(),
+            mode: Mode::Dev,
+            base_path: PathBuf::new(),
+        };
+
+        let mut route = Route::new(String::from("index.tsx"));
+        route.update_axum_info();
+
+        source_builder
+            .app
+            .route_map
+            .insert(String::from("index.rs"), route);
+
+        let dev_bundle = source_builder.generate_axum_source();
+
+        assert!(dev_bundle.contains("use tuono_lib::axum::routing::get;"));
+    }
+
+    #[test]
+    fn should_create_fallback_html_with_default_config() {
+        let mut app = App::new();
+        app.config = Some(Default::default());
+
+        let source_builder = SourceBuilder {
+            app,
+            mode: Mode::Dev,
+            base_path: PathBuf::new(),
+        };
+
+        let fallback_html = source_builder.build_html_fallback();
+
+        assert!(fallback_html.contains("http://localhost:3000/vite-server/@react-refresh"));
+        assert!(fallback_html.contains("http://localhost:3000/vite-server/@vite/client"));
+        assert!(fallback_html.contains("http://localhost:3000/vite-server/client-main.tsx"));
     }
 }

crates/tuono/src/watch.rs

@@ -1,96 +0,0 @@
-use std::sync::Arc;
-use watchexec_supervisor::command::{Command, Program};
-
-use miette::{IntoDiagnostic, Result};
-use watchexec::Watchexec;
-use watchexec_signals::Signal;
-use watchexec_supervisor::job::{start_job, Job};
-
-use crate::source_builder::{bundle_axum_source, Mode};
-
-fn watch_react_src() -> Job {
-    start_job(Arc::new(Command {
-        program: Program::Exec {
-            prog: "node_modules/.bin/tuono-dev-watch".into(),
-            args: vec![],
-        },
-        options: Default::default(),
-    }))
-    .0
-}
-
-fn build_rust_src() -> Job {
-    start_job(Arc::new(Command {
-        program: Program::Exec {
-            prog: "cargo".into(),
-            args: vec!["run".to_string(), "-q".to_string()],
-        },
-        options: Default::default(),
-    }))
-    .0
-}
-
-fn build_react_ssr_src() -> Job {
-    start_job(Arc::new(Command {
-        program: Program::Exec {
-            prog: "node_modules/.bin/tuono-dev-ssr".into(),
-            args: vec![],
-        },
-        options: Default::default(),
-    }))
-    .0
-}
-
-#[tokio::main]
-pub async fn watch() -> Result<()> {
-    println!("Starting development environment...");
-    watch_react_src().start().await;
-
-    let run_server = build_rust_src();
-
-    let build_ssr_bundle = build_react_ssr_src();
-
-    build_ssr_bundle.start().await;
-
-    run_server.start().await;
-
-    build_ssr_bundle.to_wait().await;
-
-    let wx = Watchexec::new(move |mut action| {
-        let mut should_reload = false;
-
-        for event in action.events.iter() {
-            for path in event.paths() {
-                if path.0.to_string_lossy().ends_with(".rs")
-                    // Either tsx and jsx
-                    || path.0.to_string_lossy().ends_with("sx")
-                {
-                    should_reload = true
-                }
-            }
-        }
-
-        if should_reload {
-            println!("Reloading...");
-            run_server.stop();
-            build_ssr_bundle.stop();
-            build_ssr_bundle.start();
-            bundle_axum_source(Mode::Dev).expect("Failed to bunlde rust source");
-            run_server.start();
-            println!("Ready!");
-        }
-
-        // if Ctrl-C is received, quit
-        if action.signals().any(|sig| sig == Signal::Interrupt) {
-            action.quit();
-        }
-
-        action
-    })?;
-
-    // watch the current directory
-    wx.config.pathset(["./src"]);
-
-    let _ = wx.main().await.into_diagnostic()?;
-    Ok(())
-}

crates/tuono/templates/client.ts

@@ -0,0 +1,9 @@
+// File automatically generated by tuono
+// Do not manually update this file
+import 'vite/modulepreload-polyfill'
+import { hydrate } from 'tuono/hydration'
+
+// Import the generated route tree
+import { routeTree } from './routeTree.gen'
+
+hydrate(routeTree)

crates/tuono/templates/fallback.html

@@ -0,0 +1,19 @@
+<!doctype html>
+<html>
+
+<body>
+  <script>
+    window['__TUONO_SERVER_PAYLOAD__'] = [SERVER_PAYLOAD]
+  </script>
+  <script type="module" async>
+    import RefreshRuntime from '[BASE_URL]/vite-server/@react-refresh'
+    RefreshRuntime.injectIntoGlobalHook(window)
+    window.$RefreshReg$ = () => { }
+    window.$RefreshSig$ = () => (type) => type
+    window.__vite_plugin_react_preamble_installed__ = true
+  </script>
+  <script type="module" async src="[BASE_URL]/vite-server/@vite/client"></script>
+  <script type="module" async src="[BASE_URL]/vite-server/client-main.tsx"></script>
+</body>
+
+</html>

crates/tuono/templates/server.rs

@@ -0,0 +1,26 @@
+// File automatically generated
+// Do not manually change it
+
+use tuono_lib::{tokio, Mode, Server, axum::Router, tuono_internal_init_v8_platform};
+// AXUM_GET_ROUTE_HANDLER
+
+const MODE: Mode = /*MODE*/;
+
+// MODULE_IMPORTS
+
+//MAIN_FILE_IMPORT//
+
+#[tokio::main]
+async fn main() {
+    tuono_internal_init_v8_platform();
+    println!("\n  ⚡ Tuono v/*VERSION*/");
+
+    //MAIN_FILE_DEFINITION//
+
+    let router = Router::new()
+        // ROUTE_BUILDER
+        //MAIN_FILE_USAGE//;
+
+    Server::init(router, MODE).await.start().await
+}
+

crates/tuono/templates/server.ts

@@ -0,0 +1,7 @@
+// File automatically generated by tuono
+// Do not manually update this file
+import { serverSideRendering } from 'tuono/ssr'
+
+import { routeTree } from './routeTree.gen'
+
+export const renderFn = serverSideRendering(routeTree)

crates/tuono/tests/cli_build.rs

@@ -0,0 +1,218 @@
+use assert_cmd::Command;
+use serial_test::serial;
+use std::fs;
+use tracing::Level;
+
+mod utils;
+use utils::temp_tuono_project::TempTuonoProject;
+
+const POST_API_FILE: &str = r"#[tuono_lib::api(POST)]";
+const GET_API_FILE: &str = r"#[tuono_lib::api(GET)]";
+
+fn tracing_message(level: Level, module: &str, message: &str) -> String {
+    format!("\x1b[31m{level}\x1b[0m \x1b[2mtuono::{module}\x1b[0m\x1b[2m:\x1b[0m {message}\n")
+}
+
+#[cfg(target_os = "windows")]
+const BUILD_TUONO_CONFIG: &str = ".\\node_modules\\.bin\\tuono-build-config.cmd";
+
+#[cfg(not(target_os = "windows"))]
+const BUILD_TUONO_CONFIG: &str = "./node_modules/.bin/tuono-build-config";
+
+#[test]
+#[serial]
+fn it_successfully_create_the_index_route() {
+    let temp_tuono_project = TempTuonoProject::new();
+
+    temp_tuono_project.add_file("./src/routes/index.rs");
+
+    let mut test_tuono_build = Command::cargo_bin("tuono").unwrap();
+    test_tuono_build
+        .arg("build")
+        .arg("--no-js-emit")
+        .assert()
+        .success();
+
+    let temp_main_rs_path = temp_tuono_project.path().join(".tuono/main.rs");
+
+    let temp_main_rs_content =
+        fs::read_to_string(&temp_main_rs_path).expect("Failed to read '.tuono/main.rs' content.");
+
+    assert!(temp_main_rs_content.contains(r#"#[path="../src/routes/index.rs"]"#));
+    assert!(temp_main_rs_content.contains("mod index;"));
+
+    assert!(temp_main_rs_content
+        .contains(r#".route("/", get(index::tuono_internal_route)).route("/__tuono/data/", get(index::tuono_internal_api))"#));
+}
+
+#[test]
+#[serial]
+fn it_successfully_create_an_api_route() {
+    let temp_tuono_project = TempTuonoProject::new();
+
+    temp_tuono_project.add_file_with_content("./src/routes/api/health_check.rs", POST_API_FILE);
+
+    let mut test_tuono_build = Command::cargo_bin("tuono").unwrap();
+    test_tuono_build
+        .arg("build")
+        .arg("--no-js-emit")
+        .assert()
+        .success();
+
+    let temp_main_rs_path = temp_tuono_project.path().join(".tuono/main.rs");
+
+    let temp_main_rs_content =
+        fs::read_to_string(&temp_main_rs_path).expect("Failed to read '.tuono/main.rs' content.");
+
+    assert!(temp_main_rs_content.contains(r#"#[path="../src/routes/api/health_check.rs"]"#));
+    assert!(temp_main_rs_content.contains("mod api_health_check;"));
+
+    assert!(temp_main_rs_content.contains(
+        r#".route("/api/health_check", post(api_health_check::post_tuono_internal_api))"#
+    ));
+}
+
+#[test]
+#[serial]
+fn it_successfully_create_multiple_api_for_the_same_file() {
+    let temp_tuono_project = TempTuonoProject::new();
+
+    temp_tuono_project.add_file_with_content(
+        "./src/routes/api/health_check.rs",
+        &format!("{POST_API_FILE}{GET_API_FILE}"),
+    );
+
+    let mut test_tuono_build = Command::cargo_bin("tuono").unwrap();
+    test_tuono_build
+        .arg("build")
+        .arg("--no-js-emit")
+        .assert()
+        .success();
+
+    let temp_main_rs_path = temp_tuono_project.path().join(".tuono/main.rs");
+
+    let temp_main_rs_content =
+        fs::read_to_string(&temp_main_rs_path).expect("Failed to read '.tuono/main.rs' content.");
+
+    assert!(temp_main_rs_content.contains(r#"#[path="../src/routes/api/health_check.rs"]"#));
+    assert!(temp_main_rs_content.contains("mod api_health_check;"));
+
+    assert!(temp_main_rs_content.contains(
+        r#".route("/api/health_check", post(api_health_check::post_tuono_internal_api))"#
+    ));
+    assert!(
+        temp_main_rs_content.contains(
+            r#".route("/api/health_check", get(api_health_check::get_tuono_internal_api))"#
+        )
+    );
+}
+
+#[test]
+#[serial]
+fn it_successfully_create_catch_all_routes() {
+    let temp_tuono_project = TempTuonoProject::new();
+
+    temp_tuono_project.add_file("./src/routes/[...all_routes].rs");
+
+    temp_tuono_project.add_file_with_content("./src/routes/api/[...all_apis].rs", POST_API_FILE);
+
+    let mut test_tuono_build = Command::cargo_bin("tuono").unwrap();
+    test_tuono_build
+        .arg("build")
+        .arg("--no-js-emit")
+        .assert()
+        .success();
+
+    let temp_main_rs_path = temp_tuono_project.path().join(".tuono/main.rs");
+
+    let temp_main_rs_content =
+        fs::read_to_string(&temp_main_rs_path).expect("Failed to read '.tuono/main.rs' content.");
+
+    assert!(temp_main_rs_content.contains(r#"#[path="../src/routes/api/[...all_apis].rs"]"#));
+    assert!(temp_main_rs_content.contains("mod api_dyn_catch_all_all_apis;"));
+
+    assert!(temp_main_rs_content.contains(r#"#[path="../src/routes/[...all_routes].rs"]"#));
+    assert!(temp_main_rs_content.contains("mod dyn_catch_all_all_routes;"));
+
+    assert!(temp_main_rs_content.contains(
+        r#".route("/api/{*all_apis}", post(api_dyn_catch_all_all_apis::post_tuono_internal_api))"#
+    ));
+
+    assert!(temp_main_rs_content.contains(
+        r#".route("/{*all_routes}", get(dyn_catch_all_all_routes::tuono_internal_route))"#
+    ));
+
+    assert!(temp_main_rs_content.contains(
+        r#".route("/{*all_routes}", get(dyn_catch_all_all_routes::tuono_internal_route))"#
+    ));
+
+    assert!(temp_main_rs_content.contains(
+        r#".route("/__tuono/data/{*all_routes}", get(dyn_catch_all_all_routes::tuono_internal_api))"#
+    ));
+}
+
+#[test]
+#[serial]
+fn it_fails_without_installed_build_config_script() {
+    let _guard = TempTuonoProject::new();
+
+    let mut test_tuono_build = Command::cargo_bin("tuono").unwrap();
+    test_tuono_build
+        .arg("build")
+        .assert()
+        .failure()
+        .stderr("Failed to find the build script. Please run `npm install`\n");
+}
+
+#[test]
+#[serial]
+fn it_fails_without_installed_build_script() {
+    let temp_tuono_project = TempTuonoProject::new();
+    temp_tuono_project.add_file_with_content(BUILD_TUONO_CONFIG, "#!/bin/bash");
+    Command::new("chmod")
+        .arg("+x")
+        .arg(BUILD_TUONO_CONFIG)
+        .assert()
+        .success();
+    let mut test_tuono_build = Command::cargo_bin("tuono").unwrap();
+
+    test_tuono_build
+        .arg("build")
+        .assert()
+        .failure()
+        .stderr("Failed to read config. Please run `npm install` to generate automatically.\n");
+}
+
+#[test]
+#[serial]
+fn dev_fails_with_no_config() {
+    let _temp_tuono_project = TempTuonoProject::new_with_no_config();
+
+    let mut test_tuono_build = Command::cargo_bin("tuono").unwrap();
+    test_tuono_build
+        .arg("dev")
+        .assert()
+        .failure()
+        .stdout(tracing_message(
+            Level::ERROR,
+            "source_builder",
+            "Cannot find tuono.config.ts - is this a tuono project?",
+        ));
+}
+
+#[test]
+#[serial]
+fn build_fails_with_no_config() {
+    let _temp_tuono_project = TempTuonoProject::new_with_no_config();
+
+    let mut test_tuono_build = Command::cargo_bin("tuono").unwrap();
+    test_tuono_build
+        .arg("dev")
+        .assert()
+        .failure()
+        .stdout(tracing_message(
+            Level::ERROR,
+            "source_builder",
+            "Cannot find tuono.config.ts - is this a tuono project?",
+        ));
+}

crates/tuono/tests/cli_new.rs

@@ -0,0 +1,61 @@
+use assert_cmd::Command;
+use clap::crate_version;
+use serial_test::serial;
+
+use std::fs;
+
+mod utils;
+
+use utils::mock_github_endpoint::GitHubServerMock;
+use utils::temp_tuono_project::TempTuonoProject;
+
+#[tokio::test]
+#[serial]
+async fn it_creates_a_new_project_and_replace_the_versions_in_the_manifest() {
+    let GitHubServerMock { env_vars, .. } = GitHubServerMock::new().await;
+
+    let temp_project = TempTuonoProject::new();
+
+    let project_folder = "my-project";
+
+    let mut cmd = Command::cargo_bin("tuono").unwrap();
+
+    cmd.arg("new")
+        .arg(project_folder)
+        .envs(env_vars)
+        .assert()
+        .success();
+
+    let main_rs_path = temp_project
+        .path()
+        .join(project_folder)
+        .join("src")
+        .join("main.rs");
+
+    let cargo_toml_path = temp_project.path().join(project_folder).join("Cargo.toml");
+    let package_json_path = temp_project
+        .path()
+        .join(project_folder)
+        .join("package.json");
+
+    let main_rs_content = fs::read_to_string(main_rs_path).unwrap();
+    let cargo_toml_content = fs::read_to_string(cargo_toml_path).unwrap();
+    let package_json_content = fs::read_to_string(package_json_path).unwrap();
+
+    assert_eq!(
+        main_rs_content,
+        "fn main() { println!(\"Hello, world!\"); }"
+    );
+
+    let version = crate_version!();
+
+    let expected_cargo_toml_content =
+        format!("[package] name = \"tuono-tutorial\" [dependencies] tuono_lib = \"{version}\"");
+
+    assert_eq!(cargo_toml_content, expected_cargo_toml_content);
+
+    let expected_package_json_content =
+        format!("{{\"name\": \"tuono-app\", \"dependencies\": {{ \"tuono\": \"{version}\" }}}}");
+
+    assert_eq!(package_json_content, expected_package_json_content);
+}

crates/tuono/tests/utils/mock_github_endpoint.rs

@@ -0,0 +1,101 @@
+use clap::crate_version;
+use std::env;
+use wiremock::matchers::{method, path};
+use wiremock::{Mock, MockServer, ResponseTemplate};
+
+#[allow(dead_code)]
+pub struct GitHubServerMock {
+    pub server: MockServer,
+    pub env_vars: Vec<(String, String)>,
+}
+
+#[allow(dead_code)]
+impl GitHubServerMock {
+    pub async fn new() -> Self {
+        let server = MockServer::start().await;
+
+        let tuono_version = crate_version!();
+
+        let sha = "1234567890abcdef";
+
+        let sha_response_template = ResponseTemplate::new(200).set_body_raw(
+            format!("{{ \"object\": {{ \"sha\": \"{sha}\" }} }}"),
+            "application/json",
+        );
+
+        Mock::given(method("GET"))
+            .and(path(&format!(
+                "repos/tuono-labs/tuono/git/ref/tags/v{}",
+                tuono_version
+            )))
+            .respond_with(sha_response_template)
+            .mount(&server)
+            .await;
+
+        let tree_response_template = ResponseTemplate::new(200).set_body_raw(
+            r#"{
+            "tree": [
+                {
+                    "path":  "examples/tuono-app/src",
+                    "type": "tree"
+                },
+                {
+                    "path": "examples/tuono-app/src/main.rs",
+                    "type": "blob"
+                },
+                {
+                    "path": "examples/tuono-app/Cargo.toml",
+                    "type": "blob"
+                },
+                {
+                    "path": "examples/tuono-app/package.json",
+                    "type": "blob"
+                }
+            ]
+            }"#,
+            "application/json",
+        );
+
+        Mock::given(method("GET"))
+            .and(path(&format!("repos/tuono-labs/tuono/git/trees/{}", sha)))
+            .respond_with(tree_response_template)
+            .mount(&server)
+            .await;
+
+        let file_response_template =
+            |content: &str| ResponseTemplate::new(200).set_body_raw(content, "text/plain");
+
+        Mock::given(method("GET"))
+            .and(path(format!(
+                "tuono-labs/tuono/v{tuono_version}/examples/tuono-app/src/main.rs"
+            )))
+            .respond_with(file_response_template(
+                "fn main() { println!(\"Hello, world!\"); }",
+            ))
+            .mount(&server)
+            .await;
+
+        Mock::given(method("GET"))
+            .and(path(format!(
+                "tuono-labs/tuono/v{tuono_version}/examples/tuono-app/Cargo.toml"
+            )))
+            .respond_with(file_response_template(
+                "[package] name = \"tuono-tutorial\" [dependencies] tuono_lib = { path = \"../../crates/tuono_lib/\" }"
+            ))
+            .mount(&server)
+            .await;
+
+        Mock::given(method("GET"))
+            .and(path(format!(
+                "tuono-labs/tuono/v{tuono_version}/examples/tuono-app/package.json"
+            )))
+            .respond_with(file_response_template(
+                r#"{"name": "tuono-app", "dependencies": { "tuono": "link:../../packages/tuono" }}"#,
+            ))
+            .mount(&server)
+            .await;
+
+        let env_vars = vec![("__INTERNAL_TUONO_TEST".to_string(), server.uri())];
+        GitHubServerMock { server, env_vars }
+    }
+}

crates/tuono/tests/utils/mod.rs

@@ -0,0 +1,2 @@
+pub mod mock_github_endpoint;
+pub mod temp_tuono_project;

crates/tuono/tests/utils/temp_tuono_project.rs

@@ -0,0 +1,70 @@
+use fs_extra::dir::create_all;
+use std::env;
+use std::fs::File;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use tempfile::{TempDir, tempdir};
+
+#[derive(Debug)]
+pub struct TempTuonoProject {
+    original_dir: PathBuf,
+    temp_dir: TempDir,
+}
+
+#[allow(dead_code)]
+impl TempTuonoProject {
+    pub fn new() -> Self {
+        let project = TempTuonoProject::new_with_no_config();
+
+        project.add_file("./tuono.config.ts");
+
+        project
+    }
+
+    pub fn new_with_no_config() -> Self {
+        let original_dir = env::current_dir().expect("Failed to read current_dir");
+        let temp_dir = tempdir().expect("Failed to create temp_dir");
+
+        env::set_current_dir(temp_dir.path()).expect("Failed to change current dir into temp_dir");
+
+        TempTuonoProject {
+            original_dir,
+            temp_dir,
+        }
+    }
+
+    pub fn path(&self) -> &Path {
+        self.temp_dir.path()
+    }
+
+    pub fn add_file(&self, path: &str) -> File {
+        let path = PathBuf::from(path);
+        create_all(
+            path.parent().expect("Route path does not have any parent"),
+            false,
+        )
+        .expect("Failed to create parent route directory");
+        File::create(path).expect("Failed to create the route file")
+    }
+
+    pub fn add_file_with_content<'a>(&self, path: &'a str, content: &'a str) {
+        let path = PathBuf::from(path);
+        create_all(
+            path.parent().expect("Route path does not have any parent"),
+            false,
+        )
+        .expect("Failed to create parent route directory");
+
+        let mut file = File::create(path).expect("Failed to create the route file");
+        file.write_all(content.as_bytes())
+            .expect("Failed to write into API file");
+    }
+}
+
+impl Drop for TempTuonoProject {
+    fn drop(&mut self) {
+        // Set back the current dir in the previous state
+        env::set_current_dir(&self.original_dir)
+            .expect("Failed to restore the original directory.");
+    }
+}

crates/tuono_internal/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "tuono_internal"
+version = "0.19.1"
+edition = "2024"
+authors = ["V. Ageno <valerioageno@yahoo.it>"]
+description = "Superfast React fullstack framework"
+homepage = "https://tuono.dev"
+keywords = [ "react", "typescript", "fullstack", "web", "ssr"]
+repository = "https://github.com/tuono-labs/tuono"
+readme = "../../README.md"
+license-file = "../../LICENSE.md"
+categories = ["web-programming"]
+include = [
+		"src/**/*.rs",
+		"Cargo.toml"
+]
+
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0.137"
+
+[dev-dependencies]
+fs_extra = "1.3.0"
+tempfile = "3.14.0"
+assert_cmd = "2.0.16"
+serial_test = "3.0.0"

crates/tuono_internal/README.md

@@ -0,0 +1,4 @@
+# tuono_internal
+
+This crate is a collection of internal utilities for the Tuono project. It is
+not intended for use outside of the project.

crates/tuono_internal/src/config.rs

@@ -0,0 +1,49 @@
+use serde::{Deserialize, Serialize};
+use std::fs::read_to_string;
+use std::io;
+use std::path::PathBuf;
+
+#[derive(Deserialize, Serialize, Debug, Clone)]
+pub struct ServerConfig {
+    pub host: String,
+    pub origin: Option<String>,
+    pub port: u16,
+}
+
+impl Default for ServerConfig {
+    fn default() -> Self {
+        ServerConfig {
+            host: "localhost".to_string(),
+            origin: None,
+            port: 3000,
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize, Debug, Clone, Default)]
+pub struct Config {
+    pub server: ServerConfig,
+}
+
+impl Config {
+    pub fn get() -> io::Result<Config> {
+        let config_file = read_to_string(PathBuf::from_iter([".tuono", "config", "config.json"]))?;
+
+        serde_json::from_str(&config_file)
+            .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_config_default() {
+        let config = Config::default();
+
+        assert_eq!(config.server.host, "localhost".to_string());
+        assert_eq!(config.server.origin, None);
+        assert_eq!(config.server.port, 3000);
+    }
+}

crates/tuono_internal/src/lib.rs

@@ -0,0 +1 @@
+pub mod config;

crates/tuono_internal/tests/config.rs

@@ -0,0 +1,74 @@
+mod utils;
+use serial_test::serial;
+use std::io::ErrorKind;
+use tuono_internal::config::Config;
+use utils::TempTuonoProject;
+
+#[test]
+#[serial]
+fn should_correctly_read_the_config_file() {
+    let folder = TempTuonoProject::new();
+
+    folder.add_file_with_content(
+        "./.tuono/config/config.json",
+        r#"{ "server": {"host": "localhost", "port": 3000}}"#,
+    );
+
+    let config = Config::get();
+
+    assert!(config.is_ok());
+
+    let config = config.unwrap();
+    assert_eq!(config.server.host, "localhost");
+    assert_eq!(config.server.origin, None);
+    assert_eq!(config.server.port, 3000);
+}
+
+#[test]
+#[serial]
+fn should_correctly_read_the_config_file_with_origin() {
+    let folder = TempTuonoProject::new();
+
+    folder.add_file_with_content(
+        "./.tuono/config/config.json",
+        r#"{ "server": {"host": "localhost", "origin": "https://tuono.localhost", "port": 3000}}"#,
+    );
+
+    let config = Config::get();
+
+    assert!(config.is_ok());
+
+    let config = config.unwrap();
+    assert_eq!(config.server.host, "localhost".to_string());
+    assert_eq!(
+        config.server.origin,
+        Some("https://tuono.localhost".to_string())
+    );
+    assert_eq!(config.server.port, 3000);
+}
+
+#[test]
+#[serial]
+fn should_fail_if_the_file_does_not_exist() {
+    TempTuonoProject::new();
+
+    let config = Config::get();
+
+    assert!(config.is_err());
+
+    assert_eq!(config.err().unwrap().kind(), ErrorKind::NotFound);
+}
+
+#[test]
+#[serial]
+fn should_fail_if_the_file_is_not_json() {
+    let folder = TempTuonoProject::new();
+
+    folder.add_file_with_content("./.tuono/config/config.json", "INVALID JSON");
+
+    let config = Config::get();
+
+    assert!(config.is_err());
+
+    assert_eq!(config.err().unwrap().kind(), ErrorKind::InvalidData);
+}

crates/tuono_internal/tests/utils.rs

@@ -0,0 +1,49 @@
+use fs_extra::dir::create_all;
+use std::env;
+use std::fs::File;
+use std::io::Write;
+use std::path::PathBuf;
+use tempfile::{TempDir, tempdir};
+
+#[derive(Debug)]
+pub struct TempTuonoProject {
+    original_dir: PathBuf,
+    #[allow(dead_code)]
+    // Required for dropping the temp_dir when this struct drops
+    temp_dir: TempDir,
+}
+
+impl TempTuonoProject {
+    pub fn new() -> Self {
+        let original_dir = env::current_dir().expect("Failed to read current_dir");
+        let temp_dir = tempdir().expect("Failed to create temp_dir");
+
+        env::set_current_dir(temp_dir.path()).expect("Failed to change current dir into temp_dir");
+
+        TempTuonoProject {
+            original_dir,
+            temp_dir,
+        }
+    }
+
+    pub fn add_file_with_content<'a>(&self, path: &'a str, content: &'a str) {
+        let path = PathBuf::from(path);
+        create_all(
+            path.parent().expect("File path does not have any parent"),
+            false,
+        )
+        .expect("Failed to create parent file directories");
+
+        let mut file = File::create(path).expect("Failed to create the file");
+        file.write_all(content.as_bytes())
+            .expect("Failed to write into the file");
+    }
+}
+
+impl Drop for TempTuonoProject {
+    fn drop(&mut self) {
+        // Set back the current dir in the previous state
+        env::set_current_dir(&self.original_dir)
+            .expect("Failed to restore the original directory.");
+    }
+}

crates/tuono_lib/Cargo.toml

@@ -1,31 +1,48 @@
 [package]
 name = "tuono_lib"
-version = "0.2.2"
-edition = "2021"
+version = "0.19.1"
+edition = "2024"
 authors = ["V. Ageno <valerioageno@yahoo.it>"]
-description = "The react/rust fullstack framework"
-repository = "https://github.com/Valerioageno/tuono"
+description = "Superfast React fullstack framework"
+homepage = "https://tuono.dev"
+keywords = [ "react", "typescript", "fullstack", "web", "ssr"]
+repository = "https://github.com/tuono-labs/tuono"
 readme = "../../README.md"
 license-file = "../../LICENSE.md"
-categories = ["web-programming", "reactjs", "typescript", "framework", "fullstack"]
+categories = ["web-programming"]
 include = [
-		"src/*.rs",
+    "src/**/*.rs",
 		"Cargo.toml"
 ]
 
-[lib]
-name = "tuono_lib"
-path = "src/lib.rs"
 
 [dependencies]
-ssr_rs = "0.5.4"
-axum = "0.7.5"
+ssr_rs = "0.8.2"
+axum = {version = "0.8.1", features = ["json", "ws"]}
+axum-extra = {version = "0.10.0", features = ["cookie"]}
+tokio = { version = "1.37.0", features = ["full"] }
 serde = { version = "1.0.202", features = ["derive"] }
 erased-serde = "0.4.5"
 serde_json = "1.0"
-
-tuono_lib_macros = {path = "../tuono_lib_macros", version = "0.2.2"}
+serde_urlencoded = "0.7.1"
+reqwest = {version = "0.12.4", features = ["json", "stream"]}
 once_cell = "1.19.0"
-lazy_static = "1.5.0"
 regex = "1.10.5"
+either = "1.13.0"
+tower-http = {version = "0.6.0", features = ["fs"]}
+colored = "2.1.0"
 
+tuono_lib_macros = {path = "../tuono_lib_macros", version = "0.19.1"}
+tuono_internal = {path = "../tuono_internal", version = "0.19.1"}
+# Match the same version used by axum
+tokio-tungstenite = "0.26.0"
+futures-util = { version = "0.3", default-features = false, features = ["sink", "std"] }
+tungstenite = "0.26.0"
+http = "1.1.0"
+pin-project = "1.1.7"
+tower = "0.5.1"
+
+[dev-dependencies]
+fs_extra = "1.3.0"
+tempfile = "3.14.0"
+serial_test = "3.0.0"

crates/tuono_lib/src/catch_all.rs

@@ -0,0 +1,24 @@
+use crate::{Payload, ssr::Js};
+use axum::extract::{Path, Request};
+use axum::response::Html;
+use std::collections::HashMap;
+
+pub async fn catch_all(
+    Path(params): Path<HashMap<String, String>>,
+    request: Request,
+) -> Html<String> {
+    let pathname = request.uri();
+    let headers = request.headers();
+
+    let req = crate::Request::new(pathname.to_owned(), headers.to_owned(), params, None);
+
+    // TODO: remove unwrap
+    let payload = Payload::new(&req, &"").client_payload().unwrap();
+
+    let result = Js::render_to_string(Some(&payload));
+
+    match result {
+        Ok(html) => Html(html),
+        _ => Html("500 internal server error".to_string()),
+    }
+}

crates/tuono_lib/src/config.rs

@@ -0,0 +1,4 @@
+use once_cell::sync::OnceCell;
+use tuono_internal::config::Config;
+
+pub static GLOBAL_CONFIG: OnceCell<Config> = OnceCell::new();

crates/tuono_lib/src/env.rs

@@ -0,0 +1,301 @@
+use crate::mode::Mode;
+use std::collections::HashSet;
+use std::env;
+use std::fs;
+
+/// Read the env variables from the .env files
+/// and set them in the OS env
+///
+/// This function is unsafe because it modifies the OS env variables (which needs
+/// to be done in a single-threaded context).
+pub unsafe fn load_env_vars(mode: Mode) {
+    let mut env_files = vec![String::from(".env"), String::from(".env.local")];
+
+    let mode_name = match mode {
+        Mode::Dev => "development",
+        Mode::Prod => "production",
+    };
+
+    env_files.push(format!(".env.{}", mode_name));
+    env_files.push(String::from(".env.local"));
+    env_files.push(format!(".env.{}.local", mode_name));
+
+    let system_env_names: HashSet<String> = env::vars().map(|(k, _)| k).collect();
+
+    for env_file in env_files {
+        if let Ok(contents) = fs::read_to_string(env_file) {
+            for line in contents.lines() {
+                if let Some((key, mut value)) = line.split_once('=') {
+                    if value.starts_with('"') && value.ends_with('"') {
+                        value = &value[1..value.len() - 1];
+                    }
+
+                    let key = key.trim().to_string();
+                    let value = value.trim().to_string();
+
+                    if system_env_names.contains(&key) {
+                        continue; // Skip if key exists in system env
+                    }
+
+                    unsafe {
+                        env::set_var(key, value);
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::mode::Mode;
+    use serial_test::serial;
+    use std::collections::HashMap;
+    use std::env;
+    use std::fs;
+
+    struct MockEnv {
+        files: Vec<String>,
+        vars: HashMap<String, String>,
+    }
+
+    impl MockEnv {
+        fn new() -> Self {
+            Self {
+                files: Vec::new(),
+                vars: HashMap::new(),
+            }
+        }
+
+        fn add_system_var(&mut self, k: &str, v: &str) {
+            self.vars.insert(k.to_string(), v.to_string());
+            unsafe {
+                env::set_var(k, v);
+            }
+        }
+
+        pub fn setup_env_file(&mut self, file_name: &str, contents: &str) {
+            self.files.push(file_name.to_string());
+            fs::write(file_name, contents).expect("Failed to write test .env file");
+        }
+
+        pub fn capture_keys(&mut self, keys: &[&str]) {
+            for key in keys {
+                if let Ok(val) = env::var(key) {
+                    self.vars.insert(key.to_string(), val);
+                }
+            }
+        }
+    }
+
+    impl Drop for MockEnv {
+        fn drop(&mut self) {
+            for file in self.files.iter() {
+                let _ = fs::remove_file(file.as_str());
+            }
+            for key in self.vars.keys() {
+                unsafe {
+                    env::remove_var(key);
+                }
+            }
+        }
+    }
+
+    #[test]
+    #[serial]
+    fn test_system_env_var_precedence() {
+        let mut mock_env = MockEnv::new();
+
+        mock_env.add_system_var("TEST_KEY", "system_value");
+        mock_env.setup_env_file(".env", "TEST_KEY=file_value");
+
+        unsafe {
+            load_env_vars(Mode::Dev);
+        }
+
+        mock_env.capture_keys(&["TEST_KEY"]);
+
+        assert_eq!(env::var("TEST_KEY").unwrap(), "system_value");
+    }
+
+    #[test]
+    #[serial]
+    fn test_mode_specific_env_var_precedence_dev() {
+        let mut mock_env = MockEnv::new();
+
+        mock_env.setup_env_file(".env", "TEST_KEY=base_value");
+        mock_env.setup_env_file(".env.development", "TEST_KEY=development_value");
+
+        unsafe {
+            load_env_vars(Mode::Dev);
+        }
+
+        mock_env.capture_keys(&["TEST_KEY"]);
+
+        assert_eq!(env::var("TEST_KEY").unwrap(), "development_value");
+    }
+
+    #[test]
+    #[serial]
+    fn test_mode_specific_env_var_precedence_prod() {
+        let mut mock_env = MockEnv::new();
+
+        mock_env.setup_env_file(".env", "TEST_KEY=base_value");
+        mock_env.setup_env_file(".env.production", "TEST_KEY=production_value");
+
+        unsafe {
+            load_env_vars(Mode::Prod);
+        }
+
+        mock_env.capture_keys(&["TEST_KEY"]);
+
+        assert_eq!(env::var("TEST_KEY").unwrap(), "production_value");
+    }
+
+    #[test]
+    #[serial]
+    fn test_local_env_var_precedence() {
+        let mut mock_env = MockEnv::new();
+
+        mock_env.setup_env_file(".env", "TEST_KEY=base_value");
+        mock_env.setup_env_file(".env.local", "TEST_KEY=local_value");
+
+        unsafe {
+            load_env_vars(Mode::Dev);
+        }
+
+        mock_env.capture_keys(&["TEST_KEY"]);
+
+        assert_eq!(env::var("TEST_KEY").unwrap(), "local_value");
+    }
+
+    #[test]
+    #[serial]
+    fn test_mode_local_env_var_precedence_dev() {
+        let mut mock_env = MockEnv::new();
+
+        mock_env.setup_env_file(".env", "TEST_KEY=base_value");
+        mock_env.setup_env_file(".env.development", "TEST_KEY=development_value");
+        mock_env.setup_env_file(".env.development.local", "TEST_KEY=local_dev_value");
+
+        unsafe {
+            load_env_vars(Mode::Dev);
+        }
+
+        mock_env.capture_keys(&["TEST_KEY"]);
+
+        assert_eq!(env::var("TEST_KEY").unwrap(), "local_dev_value");
+    }
+
+    #[test]
+    #[serial]
+    fn test_mode_local_env_var_precedence_prod() {
+        let mut mock_env = MockEnv::new();
+
+        mock_env.setup_env_file(".env", "TEST_KEY=base_value");
+        mock_env.setup_env_file(".env.production", "TEST_KEY=production_value");
+        mock_env.setup_env_file(".env.production.local", "TEST_KEY=local_prod_value");
+
+        unsafe {
+            load_env_vars(Mode::Prod);
+        }
+
+        mock_env.capture_keys(&["TEST_KEY"]);
+
+        assert_eq!(env::var("TEST_KEY").unwrap(), "local_prod_value");
+    }
+
+    #[test]
+    #[serial]
+    fn test_ignores_files_from_other_mode() {
+        let mut mock_env = MockEnv::new();
+
+        mock_env.setup_env_file(".env.development", "TEST_KEY=development_value");
+        mock_env.setup_env_file(".env.production", "TEST_KEY=production_value");
+
+        unsafe {
+            load_env_vars(Mode::Prod);
+        }
+
+        mock_env.capture_keys(&["TEST_KEY"]);
+
+        assert_eq!(env::var("TEST_KEY").unwrap(), "production_value");
+    }
+
+    #[test]
+    #[serial]
+    fn test_empty_env_file() {
+        let mut mock_env = MockEnv::new();
+
+        mock_env.setup_env_file(".env", "");
+
+        unsafe {
+            load_env_vars(Mode::Dev);
+        }
+
+        assert!(env::var("NON_EXISTENT_KEY").is_err());
+    }
+
+    #[test]
+    #[serial]
+    fn test_malformed_env_entries() {
+        let mut mock_env = MockEnv::new();
+
+        mock_env.setup_env_file(".env", "INVALID_LINE\nMISSING_EQUALS_SIGN");
+        unsafe {
+            load_env_vars(Mode::Dev);
+        }
+
+        mock_env.capture_keys(&["INVALID_LINE", "MISSING_EQUALS_SIGN"]);
+
+        assert!(env::var("INVALID_LINE").is_err());
+        assert!(env::var("MISSING_EQUALS_SIGN").is_err());
+    }
+
+    #[test]
+    #[serial]
+    fn test_quoted_values_parsing() {
+        let mut mock_env = MockEnv::new();
+
+        mock_env.setup_env_file(".env", r#"TEST_KEY="quoted_value""#);
+
+        unsafe {
+            load_env_vars(Mode::Dev);
+        }
+
+        mock_env.capture_keys(&["TEST_KEY"]);
+
+        assert_eq!(env::var("TEST_KEY").unwrap(), "quoted_value");
+    }
+
+    #[test]
+    #[serial]
+    fn test_non_existent_env_file() {
+        let mut mock_env = MockEnv::new();
+        unsafe {
+            load_env_vars(Mode::Dev);
+        }
+
+        mock_env.capture_keys(&["NON_EXISTENT_KEY"]);
+
+        assert!(env::var("NON_EXISTENT_KEY").is_err());
+    }
+
+    #[test]
+    #[serial]
+    fn test_multiple_env_vars() {
+        let mut mock_env = MockEnv::new();
+
+        mock_env.setup_env_file(".env", "KEY1=value1\nKEY2=value2");
+
+        unsafe {
+            load_env_vars(Mode::Dev);
+        }
+
+        mock_env.capture_keys(&["KEY1", "KEY2"]);
+
+        assert_eq!(env::var("KEY1").unwrap(), "value1");
+        assert_eq!(env::var("KEY2").unwrap(), "value2");
+    }
+}

crates/tuono_lib/src/lib.rs

@@ -1,14 +1,31 @@
-pub mod manifest;
+//! ## Tuono
+//! Tuono is a full-stack web framework for building React applications using Rust as the backend with a strong focus on usability and performance.
+//!
+//! You can find the full documentation at [tuono.dev](https://tuono.dev/)
+
+mod catch_all;
+mod config;
+mod env;
+mod manifest;
 mod mode;
 mod payload;
 mod request;
 mod response;
+mod server;
+mod services;
+mod ssr;
+mod vite_reverse_proxy;
+mod vite_websocket_proxy;
 
-pub mod ssr;
-
-pub use mode::{Mode, GLOBAL_MODE};
+pub use mode::Mode;
 pub use payload::Payload;
 pub use request::Request;
 pub use response::{Props, Response};
+pub use server::{Server, tuono_internal_init_v8_platform};
+pub use tuono_lib_macros::{api, handler};
+
+// Re-exports
+pub use axum;
+pub use axum_extra::extract::cookie;
 pub use ssr_rs::Ssr;
-pub use tuono_lib_macros::handler;
+pub use tokio;

crates/tuono_lib/src/manifest.rs

@@ -7,12 +7,19 @@ use std::path::PathBuf;
 
 const VITE_MANIFEST_PATH: &str = "./out/client/.vite/manifest.json";
 
-#[derive(Deserialize, Debug, Clone)]
+#[derive(Deserialize, Debug, Clone, PartialEq, Eq)]
 pub struct BundleInfo {
+    /// TODO: Add also the import field and load the dynamic
+    /// values in the payload bundles.
     pub file: String,
+    #[serde(default = "default_css_vector")]
     pub css: Vec<String>,
 }
 
+fn default_css_vector() -> Vec<String> {
+    Vec::with_capacity(0)
+}
+
 /// Manifest is the mapping between the vite output bundled files
 /// and the originals.
 /// Vite doc: https://vitejs.dev/config/build-options.html#build-manifest
@@ -22,7 +29,7 @@ pub fn load_manifest() {
     let file = File::open(PathBuf::from(VITE_MANIFEST_PATH)).unwrap();
     let reader = BufReader::new(file);
     let manifest = serde_json::from_reader(reader).unwrap();
-    MANIFEST.set(remap_manifest_keys(manifest)).unwrap();
+    let _ = MANIFEST.set(remap_manifest_keys(manifest));
 }
 
 fn remap_manifest_keys(manifest: HashMap<String, BundleInfo>) -> HashMap<String, BundleInfo> {
@@ -45,6 +52,73 @@ fn remap_manifest_keys(manifest: HashMap<String, BundleInfo>) -> HashMap<String,
 mod tests {
     use super::*;
 
+    #[test]
+    fn correctly_parse_the_manifest_json() {
+        let manifest_example = r#"{
+  "../src/routes/index.tsx": {
+    "file": "assets/index.js",
+    "name": "index",
+    "src": "../src/routes/index.tsx",
+    "isDynamicEntry": true,
+    "imports": [
+      "client-main.tsx"
+    ],
+    "css": [
+      "assets/index.css"
+    ]
+  },
+  "meta-tags-lib": {
+    "file": "assets/meta-lib.js",
+    "name": "meta-tags-lib",
+    "imports": [
+      "client-main.tsx"
+    ]
+  },
+  "client-main.tsx": {
+    "file": "assets/client-main.js",
+    "name": "client-main",
+    "src": "client-main.tsx",
+    "isEntry": true,
+    "dynamicImports": [
+      "../src/routes/index.tsx",
+      "../src/routes/pokemons/[pokemon].tsx"
+    ],
+    "css": [
+      "assets/client-main.css"
+    ]
+  }
+}"#;
+
+        let parsed_manifest =
+            serde_json::from_str::<HashMap<String, BundleInfo>>(manifest_example).unwrap();
+
+        let mut result = HashMap::new();
+        result.insert(
+            "../src/routes/index.tsx".to_string(),
+            BundleInfo {
+                file: "assets/index.js".to_string(),
+                css: vec!["assets/index.css".to_string()],
+            },
+        );
+        result.insert(
+            "client-main.tsx".to_string(),
+            BundleInfo {
+                file: "assets/client-main.js".to_string(),
+                css: vec!["assets/client-main.css".to_string()],
+            },
+        );
+
+        result.insert(
+            "meta-tags-lib".to_string(),
+            BundleInfo {
+                file: "assets/meta-lib.js".to_string(),
+                css: Vec::new(),
+            },
+        );
+
+        assert_eq!(parsed_manifest, result);
+    }
+
     #[test]
     fn should_correctly_remap_the_manifest() {
         let mut parsed_manifest: HashMap<String, BundleInfo> = HashMap::new();

crates/tuono_lib/src/payload.rs

@@ -1,7 +1,10 @@
-use crate::{manifest::MANIFEST, Mode, GLOBAL_MODE};
+use crate::config::GLOBAL_CONFIG;
+use crate::manifest::MANIFEST;
+use crate::mode::{GLOBAL_MODE, Mode};
 use erased_serde::Serialize;
 use regex::Regex;
 use serde::Serialize as SerdeSerialize;
+use tuono_internal::config::ServerConfig;
 
 use crate::request::{Location, Request};
 
@@ -13,23 +16,38 @@ fn has_dynamic_path(route: &str) -> bool {
 #[derive(SerdeSerialize)]
 /// This is the payload sent to the client for hydration
 pub struct Payload<'a> {
-    router: Location,
-    props: &'a dyn Serialize,
+    location: Location,
+    data: &'a dyn Serialize,
     mode: Mode,
     #[serde(rename(serialize = "jsBundles"))]
     js_bundles: Option<Vec<&'a String>>,
     #[serde(rename(serialize = "cssBundles"))]
     css_bundles: Option<Vec<&'a String>>,
+    #[serde(rename(serialize = "devServerConfig"))]
+    dev_server_config: Option<&'a ServerConfig>,
 }
 
 impl<'a> Payload<'a> {
-    pub fn new(req: &Request<'a>, props: &'a dyn Serialize) -> Payload<'a> {
+    pub fn new(req: &'a Request, data: &'a dyn Serialize) -> Payload<'a> {
+        let config = GLOBAL_CONFIG
+            .get()
+            .expect("Failed to load the current config");
+
+        let mode = *GLOBAL_MODE.get().expect("Failed to load the current mode");
+
+        let dev_server_config = if mode == Mode::Dev {
+            Some(&config.server)
+        } else {
+            None
+        };
+
         Payload {
-            router: req.location(),
-            props,
-            mode: *GLOBAL_MODE.get().expect("Failed to load the current mode"),
+            location: req.location(),
+            data,
+            mode,
             js_bundles: None,
             css_bundles: None,
+            dev_server_config,
         }
     }
 
@@ -61,7 +79,7 @@ impl<'a> Payload<'a> {
         let mut js_bundles_sources = vec![&main_bundle.file];
         let mut css_bundles_sources = main_bundle.css.iter().collect::<Vec<&String>>();
 
-        let pathname = &self.router.pathname();
+        let pathname = &self.location.pathname();
 
         let bundle_data = manifest.get(*pathname);
 
@@ -83,7 +101,7 @@ impl<'a> Payload<'a> {
                     .filter(|path| !path.is_empty())
                     .collect::<Vec<&str>>();
 
-                for dyn_route in dynamic_routes.iter() {
+                '_dynamic_routes_loop: for dyn_route in dynamic_routes.iter() {
                     let dyn_route_segments = dyn_route
                         .split('/')
                         .filter(|path| !path.is_empty())
@@ -92,6 +110,20 @@ impl<'a> Payload<'a> {
                     let mut route_segments_collector: Vec<&str> = vec![];
 
                     for i in 0..dyn_route_segments.len() {
+                        if dyn_route_segments[i].starts_with("[...") {
+                            route_segments_collector.push(dyn_route_segments[i]);
+
+                            let manifest_key = route_segments_collector.join("/");
+
+                            let route_data = manifest.get(&format!("/{manifest_key}"));
+                            if let Some(data) = route_data {
+                                js_bundles_sources.push(&data.file);
+                                data.css
+                                    .iter()
+                                    .for_each(|source| css_bundles_sources.push(source))
+                            }
+                            break '_dynamic_routes_loop;
+                        }
                         if path_segments.len() == i {
                             break;
                         }
@@ -134,7 +166,7 @@ mod tests {
 
     use crate::manifest::BundleInfo;
 
-    fn prepare_payload(uri: Option<&str>, mode: Mode) -> Payload<'static> {
+    fn prepare_payload(uri: Option<&str>, mode: Mode) -> Payload {
         let mut manifest_mock = HashMap::new();
         manifest_mock.insert(
             "client-main".to_string(),
@@ -167,6 +199,14 @@ mod tests {
                 css: vec!["assets/posts/[post]/[comment].css".to_string()],
             },
         );
+        manifest_mock.insert(
+            "/pokemons/[...catch_all]".to_string(),
+            BundleInfo {
+                file: "assets/catch_all.js".to_string(),
+                css: vec!["assets/catch_all.css".to_string()],
+            },
+        );
+
         manifest_mock.insert(
             "/posts/custom-post".to_string(),
             BundleInfo {
@@ -184,18 +224,21 @@ mod tests {
             },
         );
         MANIFEST.get_or_init(|| manifest_mock);
-        let location = Location::from(
-            &uri.unwrap_or("http://localhost:3000/")
-                .parse::<Uri>()
-                .unwrap(),
-        );
+
+        let uri = uri
+            .unwrap_or("http://localhost:3000/")
+            .parse::<Uri>()
+            .unwrap();
+
+        let location = Location::from(uri);
 
         Payload {
-            router: location,
-            props: &None::<Option<()>>,
+            location,
+            data: &None::<Option<()>>,
             mode,
             js_bundles: None,
             css_bundles: None,
+            dev_server_config: None,
         }
     }
 
@@ -271,6 +314,28 @@ mod tests {
         );
     }
 
+    #[test]
+    fn should_load_the_correct_catch_all_bundles() {
+        let mut payload = prepare_payload(
+            Some("http://localhost:3000/pokemons/a-poke/a-poke"),
+            Mode::Prod,
+        );
+        let _ = payload.client_payload();
+        assert_eq!(
+            payload.js_bundles,
+            Some(vec![
+                &"assets/bundled-file.js".to_string(),
+                &"assets/catch_all.js".to_string()
+            ])
+        );
+        assert_eq!(
+            payload.css_bundles,
+            Some(vec![
+                &"assets/bundled-file.css".to_string(),
+                &"assets/catch_all.css".to_string()
+            ])
+        );
+    }
     #[test]
     fn should_load_the_defined_path_bundles() {
         let mut payload = prepare_payload(Some("http://localhost:3000/about"), Mode::Prod);

crates/tuono_lib/src/request.rs

@@ -1,4 +1,4 @@
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
 use axum::http::{HeaderMap, Uri};
@@ -8,9 +8,9 @@ use axum::http::{HeaderMap, Uri};
 pub struct Location {
     href: String,
     pathname: String,
-    search: HashMap<String, String>,
+    #[serde(rename(serialize = "searchStr"))]
     search_str: String,
-    hash: String,
+    search: HashMap<String, String>,
 }
 
 impl Location {
@@ -19,40 +19,108 @@ impl Location {
     }
 }
 
-impl<'a> From<&'a Uri> for Location {
-    fn from(uri: &Uri) -> Self {
+impl From<Uri> for Location {
+    fn from(uri: Uri) -> Self {
+        let query = uri.query().unwrap_or("");
         Location {
+            // TODO: build correct href
             href: uri.to_string(),
             pathname: uri.path().to_string(),
-            // TODO: handler search map
-            search: HashMap::new(),
-            search_str: uri.query().unwrap_or("").to_string(),
-            hash: "".to_string(),
+            search_str: query.to_string(),
+            search: serde_urlencoded::from_str(query).unwrap_or(HashMap::new()),
         }
     }
 }
 
 #[derive(Debug, Clone)]
-pub struct Request<'a> {
-    uri: &'a Uri,
-    pub headers: &'a HeaderMap,
+pub struct Request {
+    pub uri: Uri,
+    pub headers: HeaderMap,
     pub params: HashMap<String, String>,
+    body: Option<Vec<u8>>,
 }
 
-impl<'a> Request<'a> {
+impl Request {
     pub fn new(
-        uri: &'a Uri,
-        headers: &'a HeaderMap,
+        uri: Uri,
+        headers: HeaderMap,
         params: HashMap<String, String>,
-    ) -> Request<'a> {
+        body: Option<Vec<u8>>,
+    ) -> Request {
         Request {
             uri,
             headers,
             params,
+            body,
         }
     }
 
     pub fn location(&self) -> Location {
-        Location::from(self.uri)
+        Location::from(self.uri.to_owned())
+    }
+
+    pub fn body<'de, T: Deserialize<'de>>(&'de self) -> Result<T, BodyParseError> {
+        if let Some(body) = &self.body {
+            let body = serde_json::from_slice::<T>(body)?;
+            return Ok(body);
+        }
+
+        Err(BodyParseError::Io(std::io::Error::new(
+            std::io::ErrorKind::InvalidData,
+            "Failed to read body",
+        )))
+    }
+}
+
+#[derive(Debug)]
+pub enum BodyParseError {
+    Io(std::io::Error),
+    Serde(serde_json::Error),
+}
+
+impl From<serde_json::Error> for BodyParseError {
+    fn from(err: serde_json::Error) -> BodyParseError {
+        BodyParseError::Serde(err)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[derive(Debug, Deserialize)]
+    struct FakeBody {
+        field1: bool,
+        field2: String,
+    }
+
+    #[test]
+    fn it_correctly_parse_the_body() {
+        let request = Request::new(
+            Uri::from_static("http://localhost:3000"),
+            HeaderMap::new(),
+            HashMap::new(),
+            Some(r#"{"field1": true, "field2": "hello"}"#.as_bytes().to_vec()),
+        );
+
+        let body: FakeBody = request.body().expect("Failed to parse body");
+
+        assert!(body.field1);
+        assert_eq!(body.field2, "hello".to_string());
+    }
+
+    #[test]
+    fn it_should_trigger_an_error_when_body_is_invalid() {
+        let request = Request::new(
+            Uri::from_static("http://localhost:3000"),
+            HeaderMap::new(),
+            HashMap::new(),
+            Some(r#"{"field1": true"#.as_bytes().to_vec()),
+        );
+
+        let body: Result<FakeBody, BodyParseError> = request.body();
+
+        assert!(body.is_err());
     }
 }

crates/tuono_lib/src/response.rs

@@ -1,18 +1,57 @@
 use crate::Request;
-use crate::{ssr::Js, Payload};
-use axum::http::StatusCode;
-use axum::response::{Html, IntoResponse};
+use crate::{Payload, ssr::Js};
 use axum::Json;
+use axum::http::{HeaderMap, StatusCode};
+use axum::response::{Html, IntoResponse, Redirect};
+use axum_extra::extract::cookie::{Cookie, CookieJar};
 use erased_serde::Serialize;
 
 pub struct Props {
     data: Box<dyn Serialize>,
     http_code: StatusCode,
+    cookies: CookieJar,
 }
 
 pub enum Response {
     Redirect(String),
     Props(Props),
+    // TODO: improve this tuple to support a more generic IntoResponse
+    Custom((StatusCode, HeaderMap, String)),
+}
+
+#[derive(serde::Serialize)]
+struct JsonResponseInfo {
+    redirect_destination: Option<String>,
+}
+
+impl JsonResponseInfo {
+    fn new(redirect_destination: Option<String>) -> JsonResponseInfo {
+        JsonResponseInfo {
+            redirect_destination,
+        }
+    }
+}
+
+#[derive(serde::Serialize)]
+struct JsonResponse<'a> {
+    data: Option<&'a dyn Serialize>,
+    info: JsonResponseInfo,
+}
+
+impl<'a> JsonResponse<'a> {
+    fn new(props: &'a dyn Serialize) -> Self {
+        JsonResponse {
+            data: Some(props),
+            info: JsonResponseInfo::new(None),
+        }
+    }
+
+    fn new_redirect(destination: String) -> Self {
+        JsonResponse {
+            data: None,
+            info: JsonResponseInfo::new(Some(destination)),
+        }
+    }
 }
 
 impl Props {
@@ -20,37 +59,102 @@ impl Props {
         Props {
             data: Box::new(data),
             http_code: StatusCode::OK,
+            cookies: CookieJar::new(),
         }
     }
 
+    pub fn status(&mut self, http_code: StatusCode) {
+        self.http_code = http_code;
+    }
+
     pub fn new_with_status(data: impl Serialize + 'static, http_code: StatusCode) -> Self {
         Props {
             data: Box::new(data),
             http_code,
+            cookies: CookieJar::new(),
         }
     }
+
+    pub fn add_cookie(&mut self, cookie: Cookie) {
+        let jar = self.cookies.clone().add(cookie.into_owned());
+        self.cookies = jar
+    }
 }
 
 impl Response {
-    pub fn render_to_string(&self, req: Request) -> impl IntoResponse {
+    pub fn render_to_string(&self, req: Request) -> impl IntoResponse + use<> {
         match self {
-            Self::Props(Props { data, http_code }) => {
-                let payload = Payload::new(&req, data).client_payload().unwrap();
+            Self::Props(Props {
+                data,
+                http_code,
+                cookies,
+            }) => {
+                let payload = Payload::new(&req, data.as_ref()).client_payload().unwrap();
 
-                match Js::SSR.with(|ssr| ssr.borrow_mut().render_to_string(Some(&payload))) {
-                    Ok(html) => (*http_code, Html(html)),
-                    Err(_) => (*http_code, Html("500 Internal server error".to_string())),
+                match Js::render_to_string(Some(&payload)) {
+                    Ok(html) => (*http_code, cookies.clone(), Html(html)),
+                    Err(_) => (
+                        *http_code,
+                        cookies.clone(),
+                        Html("500 Internal server error".to_string()),
+                    ),
                 }
+                .into_response()
             }
-            // TODO: Handle here other enum arms
-            _ => todo!(),
+            Self::Redirect(to) => Redirect::permanent(to).into_response(),
+            Self::Custom(response) => response.clone().into_response(),
         }
     }
 
-    pub fn json(&self) -> impl IntoResponse {
+    pub fn json(&self) -> impl IntoResponse + use<> {
         match self {
-            Self::Props(Props { data, http_code }) => (*http_code, Json(data)).into_response(),
-            _ => (StatusCode::INTERNAL_SERVER_ERROR, axum::Json("{}")).into_response(),
+            Self::Props(Props {
+                data,
+                http_code,
+                cookies,
+            }) => (
+                *http_code,
+                cookies.clone(),
+                Json(JsonResponse::new(data.as_ref())),
+            )
+                .into_response(),
+            Self::Redirect(destination) => (
+                StatusCode::PERMANENT_REDIRECT,
+                Json(JsonResponse::new_redirect(destination.to_string())),
+            )
+                .into_response(),
+            // Custom never needs the "data" response since its scope
+            // is outside the react domain
+            Self::Custom(_) => (StatusCode::OK, Json("{}")).into_response(),
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn should_update_the_props_status_and_cookie() {
+        let mut props = Props::new("{}");
+        props.status(StatusCode::NOT_FOUND);
+        props.add_cookie(Cookie::new("test", "cookie"));
+        assert_eq!(props.http_code, StatusCode::NOT_FOUND);
+        assert_eq!(
+            props.cookies.get("test").unwrap(),
+            &Cookie::new("test", "cookie")
+        );
+    }
+
+    #[test]
+    fn should_add_a_cookie_jar() {
+        let mut props = Props::new("{}");
+        props.status(StatusCode::NOT_FOUND);
+        props.add_cookie(Cookie::new("test", "cookie"));
+        assert_eq!(props.http_code, StatusCode::NOT_FOUND);
+        assert_eq!(
+            props.cookies.get("test").unwrap(),
+            &Cookie::new("test", "cookie")
+        );
+    }
+}

crates/tuono_lib/src/server.rs

@@ -0,0 +1,118 @@
+use crate::config::GLOBAL_CONFIG;
+use crate::manifest::load_manifest;
+use crate::mode::{GLOBAL_MODE, Mode};
+use axum::routing::{Router, get};
+use colored::Colorize;
+use ssr_rs::Ssr;
+use tower_http::services::ServeDir;
+use tuono_internal::config::Config;
+
+use crate::env::load_env_vars;
+use crate::{
+    catch_all::catch_all, services::logger::LoggerLayer, vite_reverse_proxy::vite_reverse_proxy,
+    vite_websocket_proxy::vite_websocket_proxy,
+};
+
+const DEV_PUBLIC_DIR: &str = "public";
+const PROD_PUBLIC_DIR: &str = "out/client";
+
+pub fn tuono_internal_init_v8_platform() {
+    Ssr::create_platform();
+}
+
+#[derive(Debug)]
+pub struct Server {
+    router: Router,
+    mode: Mode,
+    pub listener: tokio::net::TcpListener,
+    pub address: String,
+    pub origin: Option<String>,
+}
+
+impl Server {
+    fn display_start_message(&self) {
+        /*
+         * Format the server address as a valid URL so that it becomes clickable in the CLI
+         * @see https://github.com/tuono-labs/tuono/issues/460
+         */
+        let server_base_url = format!("http://{}", self.address);
+
+        if self.mode == Mode::Dev {
+            println!("  Ready at: {}\n", server_base_url.blue().bold());
+        } else {
+            println!(
+                "  Production server at: {}\n",
+                server_base_url.blue().bold()
+            );
+        }
+
+        if let Some(origin) = &self.origin {
+            println!("  Origin: {}\n", origin.blue().bold());
+        }
+    }
+
+    pub async fn init(router: Router, mode: Mode) -> Server {
+        let config = Config::get().expect("[SERVER] Failed to load config");
+
+        let _ = GLOBAL_MODE.set(mode);
+        let _ = GLOBAL_CONFIG.set(config.clone());
+
+        if mode == Mode::Prod {
+            load_manifest()
+        }
+
+        let server_address = format!("{}:{}", config.server.host, config.server.port);
+
+        unsafe {
+            // This function is unsafe because it modifies the OS env variables
+            // which is not thread-safe.
+            // However, we are using it in a controlled environment which hasn't
+            // spawned any threads yet.
+            load_env_vars(mode);
+        }
+
+        Server {
+            router,
+            mode,
+            address: server_address.clone(),
+            origin: config.server.origin.clone(),
+            listener: tokio::net::TcpListener::bind(&server_address)
+                .await
+                .expect("[SERVER] Failed to bind to address"),
+        }
+    }
+
+    pub async fn start(self) {
+        self.display_start_message();
+
+        if self.mode == Mode::Dev {
+            let router = self
+                .router
+                .to_owned()
+                .layer(LoggerLayer::new())
+                .route("/vite-server/", get(vite_websocket_proxy))
+                .route("/vite-server/{*path}", get(vite_reverse_proxy))
+                .fallback_service(
+                    ServeDir::new(DEV_PUBLIC_DIR)
+                        .fallback(get(catch_all).layer(LoggerLayer::new())),
+                );
+
+            axum::serve(self.listener, router)
+                .await
+                .expect("Failed to serve development server");
+        } else {
+            let router = self
+                .router
+                .to_owned()
+                .layer(LoggerLayer::new())
+                .fallback_service(
+                    ServeDir::new(PROD_PUBLIC_DIR)
+                        .fallback(get(catch_all).layer(LoggerLayer::new())),
+                );
+
+            axum::serve(self.listener, router)
+                .await
+                .expect("Failed to serve production server");
+        }
+    }
+}

crates/tuono_lib/src/services/logger.rs

@@ -0,0 +1,106 @@
+use colored::Colorize;
+use http::{Request, Response, method::Method};
+use pin_project::pin_project;
+use std::fmt::Debug;
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use tokio::time::Instant;
+use tower::{Layer, Service};
+
+#[derive(Clone)]
+pub struct LoggerLayer {}
+
+impl LoggerLayer {
+    pub fn new() -> Self {
+        LoggerLayer {}
+    }
+}
+
+impl<S> Layer<S> for LoggerLayer {
+    type Service = Logger<S>;
+
+    fn layer(&self, inner: S) -> Self::Service {
+        Logger::new(inner)
+    }
+}
+
+#[derive(Clone)]
+pub struct Logger<S> {
+    inner: S,
+}
+
+impl<S> Logger<S> {
+    pub fn new(inner: S) -> Self {
+        Logger { inner }
+    }
+}
+
+impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for Logger<S>
+where
+    S: Service<Request<ReqBody>, Response = Response<ResBody>>,
+    ResBody: Default,
+    <S as Service<Request<ReqBody>>>::Error: Debug,
+{
+    type Response = S::Response;
+    type Error = S::Error;
+    type Future = LoggerFuture<S::Future>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.inner.poll_ready(cx)
+    }
+
+    fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
+        let method = req.method().clone();
+        let path = req.uri().path().to_string();
+
+        LoggerFuture {
+            future: self.inner.call(req),
+            method,
+            path,
+            start: Instant::now(),
+        }
+    }
+}
+
+#[pin_project]
+pub struct LoggerFuture<F> {
+    #[pin]
+    future: F,
+    method: Method,
+    path: String,
+    start: Instant,
+}
+
+impl<F, B, E> Future for LoggerFuture<F>
+where
+    F: Future<Output = Result<Response<B>, E>>,
+    B: Default,
+    E: Debug,
+{
+    type Output = Result<Response<B>, E>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+        let res: F::Output = match this.future.poll(cx) {
+            Poll::Ready(res) => res,
+            Poll::Pending => return Poll::Pending,
+        };
+
+        if this.path.starts_with("/__tuono/data") {
+            return Poll::Ready(res);
+        }
+
+        let status_code = res.as_ref().unwrap().status();
+
+        println!(
+            "  {} {} {} in {}ms",
+            this.method,
+            this.path,
+            status_code.as_str().green(),
+            this.start.elapsed().as_millis()
+        );
+
+        Poll::Ready(res)
+    }
+}

crates/tuono_lib/src/services/mod.rs

@@ -0,0 +1 @@
+pub mod logger;

crates/tuono_lib/src/ssr.rs

@@ -1,27 +1,68 @@
-use crate::{Mode, GLOBAL_MODE};
-use lazy_static::lazy_static;
-use ssr_rs::Ssr;
+use crate::mode::{GLOBAL_MODE, Mode};
+use ssr_rs::{Ssr, SsrError};
 use std::cell::RefCell;
 use std::fs::read_to_string;
 use std::path::PathBuf;
 
-lazy_static! {
-    static ref BUNDLE_PATH: &'static str = {
-        if GLOBAL_MODE.get().unwrap() == &Mode::Dev {
-            return "./.tuono/server/dev-server.js";
-        }
-        "./out/server/prod-server.js"
-    };
-}
-
+/// For the server side rendering we need to split the implementation between dev and prod.
+/// This completely remove the multi-thread optimization on dev but allow the dev server to
+/// update the SSR result without reloading the whole server.
 pub struct Js;
 
+#[cfg(target_os = "windows")]
+const PROD_BUNDLE_PATH: &str = ".\\out\\server\\prod-server.js";
+#[cfg(target_os = "windows")]
+const DEV_BUNDLE_PATH: &str = ".\\.tuono\\server\\dev-server.js";
+
+#[cfg(not(target_os = "windows"))]
+const PROD_BUNDLE_PATH: &str = "./out/server/prod-server.js";
+#[cfg(not(target_os = "windows"))]
+const DEV_BUNDLE_PATH: &str = "./.tuono/server/dev-server.js";
+
 impl Js {
-    thread_local! {
-        pub static SSR: RefCell<Ssr<'static, 'static>> = RefCell::new(
-                Ssr::from(
-                    read_to_string(PathBuf::from(*BUNDLE_PATH)).expect("Server bundle not found"), ""
-                    ).unwrap()
-                )
+    pub fn render_to_string(payload: Option<&str>) -> Result<String, SsrError> {
+        let mode = GLOBAL_MODE.get().expect("Failed to get GLOBAL_MODE");
+
+        if *mode == Mode::Dev {
+            DevJs::render_to_string(payload)
+        } else {
+            ProdJs::SSR.with(|ssr| ssr.borrow_mut().render_to_string(payload))
+        }
+    }
+}
+
+struct ProdJs;
+
+impl ProdJs {
+    thread_local! {
+        pub static SSR: RefCell<Ssr<'static, 'static>> = RefCell::new(
+            Ssr::from(
+                read_to_string(PathBuf::from(PROD_BUNDLE_PATH)).expect("Server bundle not found"), ""
+            ).unwrap()
+        )
+    }
+}
+
+struct DevJs;
+
+impl DevJs {
+    pub fn render_to_string(params: Option<&str>) -> Result<String, SsrError> {
+        let bundle_path = read_to_string(PathBuf::from(DEV_BUNDLE_PATH));
+
+        if let Ok(source) = bundle_path {
+            let ssr = Ssr::from(source, "");
+            if let Ok(mut ssr) = ssr {
+                ssr.render_to_string(params)
+            } else {
+                let fallback_html = read_to_string(PathBuf::from("./.tuono/index.html"))
+                    .unwrap_or("Fallback HTML not loaded".to_string());
+                Ok(fallback_html.replace("[SERVER_PAYLOAD]", params.unwrap_or("")))
+            }
+        } else {
+            let fallback_html = read_to_string(PathBuf::from("./.tuono/index.html"))
+                .unwrap_or("Fallback HTML not loaded".to_string());
+
+            Ok(fallback_html.replace("[SERVER_PAYLOAD]", params.unwrap_or("")))
+        }
     }
 }

crates/tuono_lib/src/vite_reverse_proxy.rs

@@ -0,0 +1,41 @@
+use crate::config::GLOBAL_CONFIG;
+use axum::body::Body;
+use axum::extract::Path;
+
+use axum::http::{HeaderName, HeaderValue};
+use axum::response::{IntoResponse, Response};
+use reqwest::Client;
+
+pub async fn vite_reverse_proxy(Path(path): Path<String>) -> impl IntoResponse {
+    let client = Client::new();
+
+    let config = GLOBAL_CONFIG
+        .get()
+        .expect("Failed to get the internal config");
+
+    let vite_url = format!(
+        "http://{}:{}/vite-server",
+        config.server.host,
+        config.server.port + 1
+    );
+
+    match client.get(format!("{vite_url}/{path}")).send().await {
+        Ok(res) => {
+            let mut response_builder = Response::builder().status(res.status().as_u16());
+
+            {
+                let headers = response_builder.headers_mut().unwrap();
+                res.headers().into_iter().for_each(|(name, value)| {
+                    let name = HeaderName::from_bytes(name.as_ref()).unwrap();
+                    let value = HeaderValue::from_bytes(value.as_ref()).unwrap();
+                    headers.insert(name, value);
+                });
+            }
+
+            response_builder
+                .body(Body::from_stream(res.bytes_stream()))
+                .unwrap()
+        }
+        Err(_) => todo!(),
+    }
+}

crates/tuono_lib/src/vite_websocket_proxy.rs

@@ -0,0 +1,114 @@
+use crate::config::GLOBAL_CONFIG;
+use axum::extract::ws::{self, Utf8Bytes as AxumUtf8Bytes, WebSocket, WebSocketUpgrade};
+use axum::response::IntoResponse;
+use futures_util::{SinkExt, StreamExt};
+use tokio_tungstenite::connect_async;
+use tokio_tungstenite::tungstenite::{Error, Message};
+use tungstenite::ClientRequestBuilder;
+use tungstenite::client::IntoClientRequest;
+
+const VITE_WS_PROTOCOL: &str = "vite-hmr";
+
+/// This is the entry point to proxy the vite's WebSocket.
+/// The proxy is needed for allowing all the development requests to point
+/// to localhost:3000/*. This enabled the framework to be developed in a Docker
+/// environment with just the 3000 port exposed.
+pub async fn vite_websocket_proxy(ws: WebSocketUpgrade) -> impl IntoResponse {
+    ws.protocols([VITE_WS_PROTOCOL]).on_upgrade(handle_socket)
+}
+
+async fn handle_socket(mut tuono_socket: WebSocket) {
+    // Send back a message to confirm connection
+    if tuono_socket
+        .send(ws::Message::Ping("tuono connected".into()))
+        .await
+        .is_err()
+    {
+        // If is error close the connection
+        return;
+    }
+
+    let config = GLOBAL_CONFIG
+        .get()
+        .expect("Failed to get the internal config");
+
+    let vite_ws = format!(
+        "ws://{}:{}/vite-server/",
+        config.server.host,
+        config.server.port + 1
+    );
+
+    let vite_ws_request = ClientRequestBuilder::new(vite_ws.parse().unwrap())
+        .with_sub_protocol(VITE_WS_PROTOCOL)
+        .into_client_request()
+        .expect("Failed to create vite WS request");
+
+    let vite_socket = match connect_async(vite_ws_request).await {
+        Ok((stream, _)) => {
+            // Connected to vite's WebSocket
+            stream
+        }
+        Err(e) => {
+            eprintln!("Failed to connect to vite's WebSocket. Error: {e}");
+            // As fallback vite automatically connect to port 3001.
+            return;
+        }
+    };
+
+    let (mut vite_sender, mut vite_receiver) = vite_socket.split();
+    let (mut tuono_sender, mut tuono_receiver) = tuono_socket.split();
+
+    // Handle browser messages.
+    // Every message gets forwarded to the vite WebSocket
+    tokio::spawn(async move {
+        while let Some(msg) = tuono_receiver.next().await {
+            if let Ok(msg) = msg {
+                let msg_to_vite = match msg.clone() {
+                    ws::Message::Text(str) => Message::Text(str.to_string().into()),
+                    ws::Message::Pong(payload) => Message::Pong(payload),
+                    ws::Message::Ping(payload) => Message::Ping(payload),
+                    ws::Message::Binary(payload) => Message::Binary(payload),
+                    // Hard to match axum and tungstenite close payload.
+                    // Not a priority
+                    ws::Message::Close(_) => Message::Close(None),
+                };
+
+                vite_sender
+                    .send(msg_to_vite)
+                    .await
+                    .expect("Failed to tunnel msg to vite's WebSocket");
+
+                msg
+            } else {
+                // Close browser's WebSocket connection.
+                return;
+            };
+        }
+    });
+
+    // Handle vite messages.
+    // Every message gets forwarded to the browser.
+    tokio::spawn(async move {
+        while let Some(Ok(msg)) = vite_receiver.next().await {
+            let msg_to_browser = match msg {
+                Message::Text(str) => ws::Message::Text(AxumUtf8Bytes::from(str.to_string())),
+                Message::Ping(payload) => ws::Message::Ping(payload),
+                Message::Pong(payload) => ws::Message::Pong(payload),
+                Message::Binary(payload) => ws::Message::Binary(payload),
+                // Hard to match axum and tungstenite close payload.
+                // Not a priority
+                Message::Close(_) => ws::Message::Close(None),
+                _ => {
+                    eprintln!("Unexpected message from the vite WebSocket to the browser: {msg:?}");
+                    ws::Message::Text("Unhandled".to_string().into())
+                }
+            };
+
+            if let Err(err) = tuono_sender.send(msg_to_browser).await {
+                if err.to_string() != Error::AlreadyClosed.to_string() {
+                    eprintln!("Failed to send back message from vite to browser: {err}")
+                }
+            }
+        }
+    });
+}

crates/tuono_lib/tests/main.rs

@@ -0,0 +1 @@
+pub mod utils;

crates/tuono_lib/tests/server_test.rs

@@ -0,0 +1,196 @@
+mod utils;
+use crate::utils::mock_server::MockTuonoServer;
+use serial_test::serial;
+
+#[tokio::test]
+#[serial]
+async fn api_endpoint_work() {
+    let app = MockTuonoServer::spawn().await;
+
+    let client = reqwest::Client::builder()
+        .redirect(reqwest::redirect::Policy::none())
+        .build()
+        .unwrap();
+
+    let server_url = format!("http://{}:{}", &app.address, &app.port);
+
+    let response = client
+        .get(format!("{server_url}/health_check"))
+        .send()
+        .await
+        .expect("Failed to execute request.");
+
+    // Assert
+    assert!(response.status().is_success());
+    assert_eq!(Some(0), response.content_length());
+}
+
+#[tokio::test]
+#[serial]
+async fn not_found_route() {
+    let app = MockTuonoServer::spawn().await;
+
+    let client = reqwest::Client::builder()
+        .redirect(reqwest::redirect::Policy::none())
+        .build()
+        .unwrap();
+
+    let server_url = format!("http://{}:{}", &app.address, &app.port);
+
+    let response = client
+        .get(format!("{server_url}/not-found"))
+        .send()
+        .await
+        .expect("Failed to execute request.");
+
+    // TODO: This should return a 404 status code
+    assert!(response.status().is_success());
+    assert_eq!(
+        response.text().await.unwrap(),
+        "<h1>404 Not found</h1><a href=\"/\">Return home</a>"
+    );
+}
+
+#[tokio::test]
+#[serial]
+async fn index_html_route() {
+    let app = MockTuonoServer::spawn().await;
+
+    let client = reqwest::Client::builder()
+        .redirect(reqwest::redirect::Policy::none())
+        .build()
+        .unwrap();
+
+    let server_url = format!("http://{}:{}", &app.address, &app.port);
+
+    let response = client
+        .get(format!("{server_url}/"))
+        .send()
+        .await
+        .expect("Failed to execute request.");
+
+    // TODO: This should return a 404 status code
+    assert!(response.status().is_success());
+    assert!(
+        response
+            .text()
+            .await
+            .unwrap()
+            .starts_with("<!DOCTYPE html>")
+    );
+}
+
+#[tokio::test]
+#[serial]
+async fn api_route_route() {
+    let app = MockTuonoServer::spawn().await;
+
+    let client = reqwest::Client::builder()
+        .redirect(reqwest::redirect::Policy::none())
+        .build()
+        .unwrap();
+
+    let server_url = format!("http://{}:{}", &app.address, &app.port);
+
+    let response = client
+        .get(format!("{server_url}/tuono/data"))
+        .send()
+        .await
+        .expect("Failed to execute request.");
+
+    // TODO: This should return a 404 status code
+    assert!(response.status().is_success());
+    assert_eq!(
+        response.text().await.unwrap(),
+        "{\"data\":\"{}\",\"info\":{\"redirect_destination\":null}}"
+    );
+}
+
+#[tokio::test]
+#[serial]
+async fn it_reads_the_catch_all_path_parameter() {
+    let app = MockTuonoServer::spawn().await;
+
+    let client = reqwest::Client::builder()
+        .redirect(reqwest::redirect::Policy::none())
+        .build()
+        .unwrap();
+
+    let server_url = format!("http://{}:{}", &app.address, &app.port);
+
+    let response = client
+        .get(format!("{server_url}/catch_all/url_parameter"))
+        .send()
+        .await
+        .expect("Failed to execute request.");
+
+    assert!(response.status().is_success());
+    assert_eq!(response.text().await.unwrap(), "url_parameter");
+}
+
+#[tokio::test]
+#[serial]
+async fn it_reads_the_path_parameter() {
+    let app = MockTuonoServer::spawn().await;
+
+    let client = reqwest::Client::builder()
+        .redirect(reqwest::redirect::Policy::none())
+        .build()
+        .unwrap();
+
+    let server_url = format!("http://{}:{}", &app.address, &app.port);
+
+    let response = client
+        .get(format!("{server_url}/dynamic/url_parameter"))
+        .send()
+        .await
+        .expect("Failed to execute request.");
+
+    assert!(response.status().is_success());
+    assert_eq!(response.text().await.unwrap(), "url_parameter");
+}
+
+#[tokio::test]
+#[serial]
+async fn it_reads_an_env_var() {
+    let app = MockTuonoServer::spawn().await;
+
+    let client = reqwest::Client::builder()
+        .redirect(reqwest::redirect::Policy::none())
+        .build()
+        .unwrap();
+
+    let server_url = format!("http://{}:{}", &app.address, &app.port);
+
+    let response = client
+        .get(format!("{server_url}/env"))
+        .send()
+        .await
+        .expect("Failed to execute request.");
+
+    assert!(response.status().is_success());
+    assert_eq!(response.text().await.unwrap(), "foobar");
+}
+
+#[tokio::test]
+#[serial]
+async fn it_parses_the_http_body() {
+    let app = MockTuonoServer::spawn().await;
+
+    let client = reqwest::Client::builder()
+        .redirect(reqwest::redirect::Policy::none())
+        .build()
+        .unwrap();
+
+    let server_url = format!("http://{}:{}", &app.address, &app.port);
+
+    let response = client
+        .post(format!("{server_url}/api/post"))
+        .body(r#"{"data":"payload"}"#)
+        .send()
+        .await
+        .expect("Failed to execute request.");
+
+    assert!(response.status().is_success());
+    assert_eq!(response.text().await.unwrap(), "payload");
+}

crates/tuono_lib/tests/utils/catch_all.rs

@@ -0,0 +1,11 @@
+use tuono_lib::Request;
+
+#[tuono_lib::api(GET)]
+async fn read_catch_all_parameter(req: Request) -> String {
+    let param = req
+        .params
+        .get("catch_all")
+        .expect("Failed to get the catch_all param");
+
+    param.to_string()
+}

crates/tuono_lib/tests/utils/dynamic_parameter.rs

@@ -0,0 +1,11 @@
+use tuono_lib::Request;
+
+#[tuono_lib::api(GET)]
+async fn read_dynamic_parameter(req: Request) -> String {
+    let param = req
+        .params
+        .get("parameter")
+        .expect("Failed to get the catch_all param");
+
+    param.to_string()
+}

crates/tuono_lib/tests/utils/env.rs

@@ -0,0 +1,7 @@
+use std::env;
+use tuono_lib::Request;
+
+#[tuono_lib::api(GET)]
+pub async fn test_env(_req: Request) -> String {
+    env::var("MY_TEST_KEY").unwrap_or("error".parse().unwrap())
+}

crates/tuono_lib/tests/utils/health_check.rs

@@ -0,0 +1,7 @@
+use tuono_lib::Request;
+use tuono_lib::axum::http::StatusCode;
+
+#[tuono_lib::api(GET)]
+async fn health_check(_req: Request) -> StatusCode {
+    StatusCode::OK
+}

crates/tuono_lib/tests/utils/mock_server.rs

@@ -0,0 +1,115 @@
+use fs_extra::dir::create_all;
+use std::fs::File;
+use std::io::Write;
+use std::path::PathBuf;
+use std::{env, fs};
+use tempfile::{TempDir, tempdir};
+use tuono_lib::axum::routing::{get, post};
+use tuono_lib::{Mode, Server, axum::Router, tuono_internal_init_v8_platform};
+
+use crate::utils::catch_all::get_tuono_internal_api as catch_all;
+use crate::utils::dynamic_parameter::get_tuono_internal_api as dynamic_parameter;
+use crate::utils::env::get_tuono_internal_api as test_env;
+use crate::utils::health_check::get_tuono_internal_api as health_check;
+use crate::utils::post_api::post_tuono_internal_api as post_api;
+use crate::utils::route as html_route;
+use crate::utils::route::tuono_internal_api as route_api;
+
+use std::sync::Once;
+
+static INIT: Once = Once::new();
+
+fn init_v8() {
+    INIT.call_once(|| {
+        tuono_internal_init_v8_platform();
+    })
+}
+
+fn add_file_with_content<'a>(path: &'a str, content: &'a str) {
+    let path = PathBuf::from(path);
+    create_all(
+        path.parent().expect("File path does not have any parent"),
+        false,
+    )
+    .unwrap_or_else(|_| {
+        panic!(
+            "Failed to create parent file directories: {}",
+            path.display()
+        )
+    });
+
+    let mut file = File::create(path).expect("Failed to create the file");
+    file.write_all(content.as_bytes())
+        .expect("Failed to write into the file");
+}
+
+#[derive(Debug)]
+pub struct MockTuonoServer {
+    pub address: String,
+    pub port: u16,
+    original_dir: PathBuf,
+    #[allow(dead_code)]
+    // Required for dropping the temp_dir when this struct drops
+    temp_dir: TempDir,
+}
+
+impl MockTuonoServer {
+    pub async fn spawn() -> Self {
+        init_v8();
+        let original_dir = env::current_dir().expect("Failed to read current_dir");
+        let temp_dir = tempdir().expect("Failed to create temp_dir");
+
+        let react_prod_build = fs::read_to_string("./tests/assets/fake_react_build.js")
+            .expect("Failed to read fake_react_build.js");
+
+        env::set_current_dir(temp_dir.path()).expect("Failed to change current dir into temp_dir");
+
+        add_file_with_content(
+            "./.tuono/config/config.json",
+            r#"{"server": {"host": "127.0.0.1", "port": 0}}"#,
+        );
+
+        add_file_with_content("./out/server/prod-server.js", react_prod_build.as_str());
+
+        add_file_with_content(
+            "./out/client/.vite/manifest.json",
+            r#"{"client-main.tsx": { "file": "assets/index.js", "name": "index", "src": "index.tsx", "isEntry": true,"dynamicImports": [],"css": []}}"#,
+        );
+
+        add_file_with_content("./.env", r#"MY_TEST_KEY="foobar""#);
+
+        let router = Router::new()
+            .route("/", get(html_route::tuono_internal_route))
+            .route("/tuono/data", get(html_route::tuono_internal_api))
+            .route("/health_check", get(health_check))
+            .route("/route-api", get(route_api))
+            .route("/catch_all/{*catch_all}", get(catch_all))
+            .route("/dynamic/{parameter}", get(dynamic_parameter))
+            .route("/api/post", post(post_api))
+            .route("/env", get(test_env));
+
+        let server = Server::init(router, Mode::Prod).await;
+
+        let socket = server
+            .listener
+            .local_addr()
+            .expect("Failed to extract test server socket");
+
+        _ = tokio::spawn(server.start());
+
+        MockTuonoServer {
+            address: socket.ip().to_string(),
+            port: socket.port(),
+            original_dir,
+            temp_dir,
+        }
+    }
+}
+
+impl Drop for MockTuonoServer {
+    fn drop(&mut self) {
+        // Set back the current dir in the previous state
+        env::set_current_dir(&self.original_dir)
+            .expect("Failed to restore the original directory.");
+    }
+}

crates/tuono_lib/tests/utils/mod.rs

@@ -0,0 +1,7 @@
+pub mod catch_all;
+pub mod dynamic_parameter;
+pub mod env;
+pub mod health_check;
+pub mod mock_server;
+pub mod post_api;
+pub mod route;

crates/tuono_lib/tests/utils/post_api.rs

@@ -0,0 +1,12 @@
+use serde::Deserialize;
+use tuono_lib::Request;
+
+#[derive(Deserialize)]
+struct Payload {
+    data: String,
+}
+
+#[tuono_lib::api(POST)]
+async fn health_check(req: Request) -> String {
+    req.body::<Payload>().unwrap().data
+}

crates/tuono_lib/tests/utils/route.rs

@@ -0,0 +1,6 @@
+use tuono_lib::{Props, Request, Response};
+
+#[tuono_lib::handler]
+async fn route(_: Request) -> Response {
+    Response::Props(Props::new("{}"))
+}

crates/tuono_lib_macros/Cargo.toml

@@ -1,21 +1,22 @@
 [package]
 name = "tuono_lib_macros"
-version = "0.2.2"
-edition = "2021"
-description = "The react/rust fullstack framework"
-repository = "https://github.com/Valerioageno/tuono"
+version = "0.19.1"
+edition = "2024"
+description = "Superfast React fullstack framework"
+homepage = "https://tuono.dev"
+keywords = [ "react", "typescript", "fullstack", "web", "ssr"]
+repository = "https://github.com/tuono-labs/tuono"
 readme = "../../README.md"
 license-file = "../../LICENSE.md"
-categories = ["web-programming", "reactjs", "typescript", "framework", "fullstack"]
+categories = ["web-programming"]
 include = [
-		"src/*.rs",
+		"src/**/*.rs",
 		"Cargo.toml"
 ]
 
 [lib]
-crate_type = ["proc-macro"]
-proc-marco = true
+proc-macro = true
 
 [dependencies]
-syn = { version = "1.0.59", features = ["full"] }
+syn = { version = "2.0.0", features = ["full"] }
 quote = "1.0"

crates/tuono_lib_macros/src/api.rs

@@ -0,0 +1,88 @@
+use crate::utils::{
+    crate_application_state_extractor, create_struct_fn_arg, import_main_application_state,
+    params_argument, request_argument,
+};
+use proc_macro::{Span, TokenStream};
+use quote::quote;
+use syn::punctuated::Punctuated;
+use syn::token::Comma;
+use syn::{FnArg, Ident, ItemFn, Pat, parse_macro_input};
+
+pub fn api_core(attrs: TokenStream, item: TokenStream) -> TokenStream {
+    let item = parse_macro_input!(item as ItemFn);
+    let http_method = parse_macro_input!(attrs as Ident)
+        .to_string()
+        .to_lowercase();
+
+    let api_fn_name = Ident::new(
+        &format!("{}_tuono_internal_api", http_method),
+        Span::call_site().into(),
+    );
+
+    let fn_name = &item.sig.ident;
+    let return_type = &item.sig.output;
+
+    let mut argument_names: Punctuated<Pat, Comma> = Punctuated::new();
+    let mut axum_arguments: Punctuated<FnArg, Comma> = Punctuated::new();
+
+    // Fn Arguments minus the first which always is the request
+    for (i, arg) in item.sig.inputs.iter().enumerate() {
+        if i == 0 {
+            axum_arguments.insert(i, params_argument());
+            continue;
+        }
+
+        if i == 1 {
+            axum_arguments.insert(1, create_struct_fn_arg())
+        }
+
+        if let FnArg::Typed(pat_type) = arg {
+            let index = i - 1;
+            let argument_name = *pat_type.pat.clone();
+            argument_names.insert(index, argument_name.clone());
+        }
+    }
+
+    axum_arguments.insert(axum_arguments.len(), request_argument());
+
+    let application_state_extractor = crate_application_state_extractor(argument_names.clone());
+    let application_state_import = import_main_application_state(argument_names.clone());
+
+    let modified_request = if http_method == "post"
+        || http_method == "put"
+        || http_method == "patch"
+    {
+        quote! {
+            let (parts, body) = request.into_parts();
+            let path = parts.uri.clone();
+            let headers = parts.headers.clone();
+
+            let body = tuono_lib::axum::body::to_bytes(body, usize::MAX).await.unwrap_or(Vec::new().into()).to_vec();
+
+            let req = tuono_lib::Request::new(path, headers, params, Some(body));
+        }
+    } else {
+        quote! {
+           let pathname = request.uri();
+           let headers = request.headers();
+
+           let req = tuono_lib::Request::new(request.uri().to_owned(), request.headers().to_owned(), params, None);
+        }
+    };
+
+    quote! {
+        #application_state_import
+
+        #item
+
+        pub async fn #api_fn_name(#axum_arguments)#return_type {
+
+           #application_state_extractor
+
+           #modified_request
+
+           #fn_name(req.clone(), #argument_names).await
+        }
+    }
+    .into()
+}

crates/tuono_lib_macros/src/handler.rs

@@ -1,44 +1,76 @@
+use crate::utils::{
+    crate_application_state_extractor, create_struct_fn_arg, import_main_application_state,
+    params_argument, request_argument,
+};
+
 use proc_macro::TokenStream;
 use quote::quote;
-use syn::{parse_macro_input, ItemFn};
+use syn::punctuated::Punctuated;
+use syn::token::Comma;
+use syn::{FnArg, ItemFn, Pat, parse_macro_input};
 
 pub fn handler_core(_args: TokenStream, item: TokenStream) -> TokenStream {
     let item = parse_macro_input!(item as ItemFn);
 
-    let fn_name = item.clone().sig.ident;
+    let fn_name = &item.sig.ident;
+
+    let mut argument_names: Punctuated<Pat, Comma> = Punctuated::new();
+    let mut axum_arguments: Punctuated<FnArg, Comma> = Punctuated::new();
+
+    // Fn Arguments minus the first which always is the request
+    for (i, arg) in item.sig.inputs.iter().enumerate() {
+        if i == 0 {
+            axum_arguments.insert(i, params_argument());
+            continue;
+        }
+
+        if i == 1 {
+            axum_arguments.insert(1, create_struct_fn_arg())
+        }
+
+        if let FnArg::Typed(pat_type) = arg {
+            let index = i - 1;
+            let argument_name = *pat_type.pat.clone();
+            argument_names.insert(index, argument_name.clone());
+        }
+    }
+
+    axum_arguments.insert(axum_arguments.len(), request_argument());
+
+    let application_state_extractor = crate_application_state_extractor(argument_names.clone());
+    let application_state_import = import_main_application_state(argument_names.clone());
 
     quote! {
-        use axum::response::IntoResponse;
-        use std::collections::HashMap;
-        use axum::extract::{State, Path};
-        use reqwest::Client;
+        #application_state_import
 
         #item
 
-        pub async fn route(
-            Path(params): Path<HashMap<String, String>>,
-            State(client): State<Client>,
-            request: axum::extract::Request
-        ) -> impl IntoResponse {
-           let pathname = &request.uri();
-           let headers = &request.headers();
+        pub async fn tuono_internal_route(
+            #axum_arguments
+        ) -> impl tuono_lib::axum::response::IntoResponse {
 
-           let req = tuono_lib::Request::new(pathname, headers, params);
+            #application_state_extractor
 
-           #fn_name(req.clone(), client).await.render_to_string(req)
+           let pathname = request.uri();
+           let headers = request.headers();
+
+           let req = tuono_lib::Request::new(pathname.to_owned(), headers.to_owned(), params, None);
+
+           #fn_name(req.clone(), #argument_names).await.render_to_string(req)
         }
 
-        pub async fn api(
-            Path(params): Path<HashMap<String, String>>,
-            State(client): State<Client>,
-            request: axum::extract::Request
-        ) -> impl IntoResponse{
-           let pathname = &request.uri();
-           let headers = &request.headers();
+        pub async fn tuono_internal_api(
+            #axum_arguments
+        ) -> impl tuono_lib::axum::response::IntoResponse {
 
-           let req = tuono_lib::Request::new(pathname, headers, params);
+            #application_state_extractor
 
-           #fn_name(req.clone(), client).await.json()
+           let pathname = request.uri();
+           let headers = request.headers();
+
+           let req = tuono_lib::Request::new(pathname.to_owned(), headers.to_owned(), params, None);
+
+           #fn_name(req.clone(), #argument_names).await.json()
         }
     }
     .into()

crates/tuono_lib_macros/src/lib.rs

@@ -1,9 +1,21 @@
+//! ## Tuono
+//! Tuono is a full-stack web framework for building React applications using Rust as the backend with a strong focus on usability and performance.
+//!
+//! You can find the full documentation at [tuono.dev](https://tuono.dev/)
+
 extern crate proc_macro;
 use proc_macro::TokenStream;
 
+mod api;
 mod handler;
+mod utils;
 
 #[proc_macro_attribute]
 pub fn handler(args: TokenStream, item: TokenStream) -> TokenStream {
     handler::handler_core(args, item)
 }
+
+#[proc_macro_attribute]
+pub fn api(args: TokenStream, item: TokenStream) -> TokenStream {
+    api::api_core(args, item)
+}

crates/tuono_lib_macros/src/utils.rs

@@ -0,0 +1,47 @@
+use quote::quote;
+use syn::punctuated::Punctuated;
+use syn::token::Comma;
+use syn::{FnArg, Pat, Stmt, parse_quote, parse2};
+
+pub fn create_struct_fn_arg() -> FnArg {
+    parse2(quote! {
+        tuono_lib::axum::extract::State(state): tuono_lib::axum::extract::State<ApplicationState>
+    })
+    .unwrap()
+}
+
+pub fn import_main_application_state(argument_names: Punctuated<Pat, Comma>) -> Option<Stmt> {
+    if !argument_names.is_empty() {
+        let local: Stmt = parse_quote!(
+            use crate::tuono_main_state::ApplicationState;
+        );
+        return Some(local);
+    }
+
+    None
+}
+
+pub fn crate_application_state_extractor(argument_names: Punctuated<Pat, Comma>) -> Option<Stmt> {
+    if !argument_names.is_empty() {
+        let use_item: Stmt = parse_quote!(let ApplicationState { #argument_names, .. } = state;);
+        return Some(use_item);
+    }
+
+    None
+}
+
+pub fn params_argument() -> FnArg {
+    parse2(quote! {
+        tuono_lib::axum::extract::Path(params): tuono_lib::axum::extract::Path<
+            std::collections::HashMap<String, String>
+        >
+    })
+    .unwrap()
+}
+
+pub fn request_argument() -> FnArg {
+    parse2(quote! {
+            request: tuono_lib::axum::extract::Request
+    })
+    .unwrap()
+}

devtools/vite-config/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "vite-config",
+  "version": "1.0.0",
+  "type": "module",
+  "private": true,
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "default": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint .",
+    "format": "prettier --check --ignore-unknown --ignore-path ../../.prettierignore .",
+    "format:fix": "prettier --write --ignore-unknown --ignore-path ../../.prettierignore .",
+    "types": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "oxc-transform": "0.61.2",
+    "rollup-plugin-preserve-directives": "0.4.0",
+    "unplugin-isolated-decl": "0.11.2",
+    "vite": "6.1.2",
+    "vite-plugin-externalize-deps": "0.9.0"
+  }
+}

devtools/vite-config/src/index.ts

@@ -0,0 +1,37 @@
+import type { UserConfig } from 'vite'
+import { preserveDirectives } from 'rollup-plugin-preserve-directives'
+import { externalizeDeps } from 'vite-plugin-externalize-deps'
+import UnpluginIsolatedDecl from 'unplugin-isolated-decl/vite'
+
+interface Options {
+  /** Entry file, e.g. `./src/index.ts` */
+  entry: string | Array<string>
+}
+
+export function defineViteConfig({ entry }: Options): UserConfig {
+  const outDir = 'dist'
+
+  return {
+    build: {
+      outDir,
+      minify: false,
+      sourcemap: true,
+      lib: {
+        entry,
+        formats: ['es'],
+        fileName: 'esm/[name]',
+      },
+      rollupOptions: {
+        output: {
+          preserveModules: true,
+          entryFileNames: 'esm/[name].js',
+        },
+      },
+    },
+    plugins: [
+      externalizeDeps(),
+      preserveDirectives(),
+      UnpluginIsolatedDecl({ transformer: 'oxc' }),
+    ],
+  }
+}

devtools/vite-config/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src"],
+  "compilerOptions": {
+    // Modules
+    "moduleResolution": "node16",
+    "module": "Node16",
+
+    // Emit
+    "noEmit": false,
+    "declaration": true,
+    "outDir": "dist"
+  }
+}

docker/.dockerignore

@@ -0,0 +1,19 @@
+# project
+node_modules
+.pnpm-store
+target
+.turbo
+
+# git
+.git
+.gitignore
+
+# docker
+docker/compose.yml
+docker/Dockerfile
+docker/.dockerignore
+
+# IDE
+.vscode
+.idea
+*.iml

docker/Dockerfile

@@ -0,0 +1,51 @@
+# ARGs obtained from the compose.yml file
+
+ARG BASE_OS=bookworm
+ARG RUST_VERSION=1.83
+
+FROM rust:${RUST_VERSION}-${BASE_OS}
+
+# Nodejs installation
+
+RUN ["mkdir", "/usr/local/node"]
+WORKDIR /usr/local/node
+
+## Retrieves the targeted version of Node in the container
+
+COPY .nvmrc /tmp/.nvmrc
+
+## Download the Node.js standelone binary archive && extract it && clean files
+
+RUN ["/bin/sh", "-c", "NODE_VERSION=$(cat /tmp/.nvmrc | tr -d '\r') && \
+    wget https://nodejs.org/dist/v${NODE_VERSION}/node-v${NODE_VERSION}-linux-x64.tar.xz && \
+    tar xf node-v${NODE_VERSION}-linux-x64.tar.xz --strip-components 1 && \
+    rm node-v${NODE_VERSION}-linux-x64.tar.xz /tmp/.nvmrc"]
+
+## Ensure Node.js binaries are available in the PATH
+
+ENV PATH /usr/local/node/bin:$PATH
+
+# cargo-watch installation (for Rust live-reloading during dev')
+
+RUN ["cargo", "install", "cargo-watch"]
+
+# global configuration done ! let's focus on the project itself
+
+## Copy project files into the container (excepted files/dir declared in .dockerignore) to /tuono directory
+
+WORKDIR /tuono
+COPY . .
+
+# pnpm installation based on version found in package.json
+
+RUN ["corepack", "enable"]
+RUN ["corepack", "install"]
+
+## Install Node.js dependencies (defined in package.json)
+
+RUN ["pnpm", "install", "--frozen-lockfile"]
+
+## Compile and add the directory with compiled binaries to the PATH for direct access
+
+RUN ["cargo", "build"]
+ENV PATH=/tuono/target/debug:$PATH

docker/compose.yml

@@ -0,0 +1,27 @@
+services:
+  tuono:
+    platform: linux/amd64
+    container_name: tuono-source-container
+    hostname: tuono-source-container
+    build:
+      context: ../
+      dockerfile: ./docker/Dockerfile
+      args:
+        RUST_VERSION: 1.83 # if change, think to update the default ARGs in Dockerfile
+        BASE_OS: bookworm # if change, think to update the default ARGs in Dockerfile
+    image: tuono-source-image
+    ports:
+      - '3000:3000' # expose default port used by tuono server
+    volumes: # mount the project into a volume but node_modules / .pnpm-store / target / ... directories won't by sync from container to host
+      - ..:/tuono
+      - /tuono/node_modules
+      - /tuono/target
+      - /tuono/.pnpm-store
+      - /tuono/.turbo
+      - /tuono/examples/tuono-app/node_modules
+      - /tuono/examples/tuono-app/target
+      - /tuono/examples/tuono-tutorial/node_modules
+      - /tuono/examples/tuono-tutorial/target
+      - /tuono/examples/with-mdx/node_modules
+      - /tuono/examples/with-mdx/target
+    tty: true

docs/tutorial.md

@@ -1,574 +0,0 @@
-# Tuono tutorial
-
-This tutorial is meant for giving you a sneak peek of the framework and is intended to evolve along the development - be sure to have installed the latest version.
-
-The first part is about the project setup and the base knowledge needed to work with tuono. The actual tutorial starts at [Tutorial introduction](#tutorial-introduction).
-
-> I'd love to hear your thoughts about the framework and the tutorial - feel free to reach me 
-at [valerioageno@yahoo.it](mailto:valerioageno@yahoo.it) or on Twitter (X) DMs 
-[@valerioageno](https://twitter.com/valerioageno)
-
-This tutorial is **not meant** for people that don't know React - in that case I suggest you to first read the [React doc](https://react.dev/);
-
-Typescript and Rust knowledge is not a requirement though!
-
-## Table of Content
-
-* [CLI Installation](#cli-installation)
-* [Project scaffold](#project-scaffold)
-* [Start the dev environment](#start-the-dev-environment)
-* [The “/” route](#the--route)
-* [Tutorial introduction](#tutorial-introduction)
-* [Fetch all the pokemons](#fetch-all-the-pokemons)
-* [Create a stand-alone component](#create-a-stand-alone-component)
-* [Create the /pokemons/[pokemon] route](#create-the-pokemonspokemon-route)
-* [Error handling](#error-handling)
-* [Building for production](#building-for-production)
-* [Conclusion](#conclusion)
-
-## CLI Installation
-
-The tuono CLI is hosted on [crates.io](https://crates.io/crates/tuono); to download and install it just run on a terminal:
-
-```bash
-$ cargo install tuono
-```
-
-To check that is correctly installed run:
-
-```bash
-$ tuono --version
-```
-
-Run `tuono -h` to see all the available commands.
-
-## Project scaffold
-
-To setup a new fresh project you just need to run the following command:
-
-```bash
-$ tuono new tuono-tutorial
-```
-
-Get into the project folder and install the dependencies with:
-
-```bash
-$ pnpm install
-```
-
-Open it with your favourite code editor.
-
-The project will have the following structure:
-
-```
-├── package.json
-├── public
-├── src
-│   ├── routes
-│   └── styles
-├── Cargo.toml
-├── README.md
-└── tsconfig.json
-```
-
-**public/**: put here all the files you want to be public
-
-**src/routes/**: All the files in this folder are considered routes. All the routes are server side rendered out of the box. To add server side capabilities just create a rust file with the same name as the route (i.e. `about.tsx` → `about.rs`).
-
-**src/styles/**: In this folder there is the `global.css` file that stores all the global styles. For the rest of the project you can use CSS modules (⚠️ CSS modules on routes are forbidden). 
-
-## Start the dev environment
-
-To start the development environment you just need to run the following command within the project folder:
-
-```bash
-$ tuono dev
-```
-The first time might take a little bit because it will install all the rust’s dependencies. All the other execution will be pretty quick!
-
-> 💡 The `tuono dev` development script is currently under strong optimization improvements. In case you face any error delete the cache `.tuono` folder and run it again!
-
-Then open [`http://localhost:3000/`](http://localhost:3000/) on the browser.
-
-## The “/” route
-
-All the `index.tsx` files represent the folder root page (i.e. `src/routes/posts/index.tsx` is [`http://localhost:3000/posts`](http://localhost:3000/posts) as well as `src/routes/posts.tsx`).
-
-The file `index.rs` represents the server side capabilities for the index route. On this file you can:
-
-- Passing server side props
-- Changing http status code
-- Redirect/Rewrite to a different route (Available soon)
-
-## Tutorial introduction
-
-Now that we have some knowledge about the project structure let’s start the real tutorial. 
-
-The goal is to use the [PokeAPI](https://pokeapi.co/docs/v2) to list all the pokemons of the first generation (the best one btw) and then reserve a dynamic page for each one separately.
-
-> If you have already installed the tuono CLI and you prefer read the code instead of writing it yourself 
-you can download the tutorial source with `tuono new tuono-tutorial --template tutorial`
-
-## Fetch all the pokemons
-
-To start let’s fetch all of them in the root page; since we want to render them on the server side we gonna need to implement the logic in the `index.rs` file.
-
-Clear the `index.rs` file and paste:
-
-```rust
-// src/routes/index.rs
-use serde::{Deserialize, Serialize};
-use tuono_lib::{Props, Request, Response};
-
-const ALL_POKEMON: &str = "https://pokeapi.co/api/v2/pokemon?limit=151";
-
-#[derive(Debug, Serialize, Deserialize)]
-struct Pokemons {
-    results: Vec<Pokemon>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct Pokemon {
-    name: String,
-    url: String,
-}
-
-#[tuono_lib::handler]
-async fn get_all_pokemons(_req: Request<'_>, fetch: reqwest::Client) -> Response {
-    return match fetch.get(ALL_POKEMON).send().await {
-        Ok(res) => {
-            let data = res.json::<Pokemons>().await.unwrap();
-            Response::Props(Props::new(data))
-        }
-        Err(_err) => Response::Props(Props::new("{}")),
-    };
-}
-```
-
-Now the pokemons are correctly fetched and hydrated on the client side so we can actually use them. Clear the `index.tsx` file and paste:
-
-```tsx
-// src/routes/index.tsx
-import type { TuonoProps } from "tuono";
-
-interface Pokemon {
-  name: string
-}
-
-interface IndexProps {
-  results: Pokemon[]
-}
-
-export default function IndexPage({
-  data,
-}: TuonoProps<IndexProps>): JSX.Element {
-  if (!data?.results) {
-    return <></>;
-  }
-
-  return (
-    <>
-      <header className="header">
-        <a href="https://crates.io/crates/tuono" target="_blank">
-          Crates
-        </a>
-        <a href="https://www.npmjs.com/package/tuono" target="_blank">
-          Npm
-        </a>
-      </header>
-      <div className="title-wrap">
-        <h1 className="title">
-          TU<span>O</span>NO
-        </h1>
-        <div className="logo">
-          <img src="rust.svg" className="rust" />
-          <img src="react.svg" className="react" />
-        </div>
-      </div>
-      <ul style={{ flexWrap: "wrap", display: "flex", gap: 10 }}>
-        {data.results.map((pokemon) => {
-          return pokemon.name;
-        })}
-      </ul>
-    </>
-  );
-}
-```
-
-Refresh now the browser! A bit ugly but all the pokemons are finally printed on screen!
-
-## Create a stand-alone component
-
-Let’s then create the button needed for displaying the list of pokemons.
-
-Create the following file `src/components/PokemonLink.tsx` and fill the content with:
-
-```tsx
-// src/components/PokemonLink.tsx
-import { Link } from "tuono";
-
-interface Pokemon {
-  name: string
-}
-
-export default function PokemonLink({
-  pokemon,
-  id,
-}: {
-  pokemon: Pokemon;
-  id: number;
-}): JSX.Element {
-  return (
-    <Link href={`/pokemons/${pokemon.name}`}>
-      {pokemon.name}
-      <img
-        src={`https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/${id}.png`}
-      />
-    </Link>
-  );
-}
-```
-
-Now that the link is done let’s import it in the `index.tsx` file
-
-```diff
-// src/routes/index.tsx
-
-++  import PokemonLink from '../components/PokemonLink'
-
-// ...
-	<ul style={{ flexWrap: "wrap", display: "flex", gap: 10 }}>
---      {pokemons.map((pokemon) => {
---        return pokemon.name;
-++      {pokemons.map((pokemon, i) => {
-++        return <PokemonLink pokemon={pokemon} id={i + 1} key={i} />;
-      })}
-	</ul>
-// ...
-```
-
-Now the links work. Clicking on any of them we get redirected to the 404 page because we haven’t yet implemented the `pokemons/[pokemon]` page. 
-As previously said CSS modules are enabled out of the box so let’s make those links a little bit nicer.
-
-Create alongside the `PokemonLink.tsx` component the CSS module `PokemonLink.module.css` and copy the following content into it:
-
-```css
-/* src/components/PokemonLink.module.css */
-
-.link {
-  width: 100%;
-  max-width: 216px;
-  position: relative;
-  background: white;
-  margin-bottom: 10px;
-  border: solid #f0f0f0 1px;
-  text-decoration: none;
-  color: black;
-  padding: 5px 5px 5px 15px;
-  border-radius: 10px;
-  display: flex;
-  justify-content: space-between;
-  transition: 0.2s;
-  align-items: center;
-}
-
-.link:hover {
-  box-shadow: rgba(100, 100, 111, 0.2) 0px 7px 29px 0px;
-}
-
-.link img {
-  width: 70px;
-  background: white;
-  border-radius: 50%;
-}
-```
-
-> 💡 SASS is supported out of the box. Just install the processor in the devDependencies `pnpm i -D sass` and run again `tuono dev`
-
-Then import the styles into the `PokemonLink` component as following:
-
-```diff
-// src/components/PokemonLink.tsx
-import { Link } from "tuono";
-import type { Pokemon } from "./../types/pokemon";
-++ import styles from './PokemonLink.module.css'
-
-export default function PokemonLink({
-  pokemon,
-  id,
-}: {
-  pokemon: Pokemon;
-  id: number;
-}): JSX.Element {
-  return (
---    <Link href={`/pokemons/${pokemon.name}`}>
-++    <Link className={styles.link} href={`/pokemons/${pokemon.name}`}>
-      {pokemon.name}
-      <img
-        src={`https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/${id}.png`}
-      />
-    </Link>
-  );
-}
-```
-
-## Create the `/pokemons/[pokemon]` route
-
-The homepage is ready. We have the full list of pokemons and they are all links. Great!
-
-Now we want to make those links actually pointing to a real page. Let’s create the dynamic route.
-
-Create the folder `routes/pokemons` and then create the two files `[pokemon].tsx` and `[pokemon].rs`.
-
-These two will handle every requests that points to `http://localhost:3000/pokemons/bulbasaur..mew`.
-
-Let’s first work on the server side file. Paste into the new `[pokemon].rs` file the following code:
-
-```rust
-// src/routes/pokemons/[pokemon].rs
-use serde::{Deserialize, Serialize};
-use tuono_lib::{Props, Request, Response};
-
-const POKEMON_API: &str = "https://pokeapi.co/api/v2/pokemon";
-
-#[derive(Debug, Serialize, Deserialize)]
-struct Pokemon {
-    name: String,
-    id: u16,
-    weight: u16,
-    height: u16,
-}
-
-#[tuono_lib::handler]
-async fn get_pokemon(req: Request<'_>, fetch: reqwest::Client) -> Response {
-    // The param `pokemon` is defined in the route filename [pokemon].rs
-    let pokemon = req.params.get("pokemon").unwrap();
-
-    return match fetch.get(format!("{POKEMON_API}/{pokemon}")).send().await {
-        Ok(res) => {
-            let data = res.json::<Pokemon>().await.unwrap();
-            Response::Props(Props::new(data))
-        }
-        Err(_err) => Response::Props(Props::new("{}"))
-    };
-}
-```
-
-Then let’s work on the frontend. Paste into the `[pokemon].tsx` file the following code:
-
-```tsx
-import { TuonoProps } from "tuono";
-import PokemonView from "../../components/PokemonView";
-
-export default function Pokemon({ data }: TuonoProps): JSX.Element {
-  return <PokemonView pokemon={data} />;
-}
-```
-
-The browser should complain that the component `PokemonView` does not exist. Let’s create it then!
-
-```tsx
-// components/PokemonView.tsx
-import { Link } from "tuono";
-import styles from "./PokemonView.module.css";
-
-interface Pokemon {
-  name: string
-  id: string
-  weight: number
-  height: number
-}
-
-export default function PokemonView({
-  pokemon,
-}: {
-  pokemon?: Pokemon;
-}): JSX.Element {
-  return (
-    <div>
-      <Link className={styles["back-btn"]} href="/">
-        Back
-      </Link>
-      {pokemon?.name && (
-        <div className={styles.pokemon}>
-          <div>
-            <h1 className={styles.name}>
-              {pokemon.name}
-            </h1>
-            <dl className={styles.spec}>
-              <dt className={styles.label}>Weight:</dt>
-              <dd>{pokemon.weight}lbs</dd>
-            </dl>
-            <dl className={styles.spec}>
-              <dt className={styles.label}>Height:</dt>
-              <dd>{pokemon.height}ft</dd>
-            </dl>
-          </div>
-          <img
-            src={`https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/other/official-artwork/${pokemon.id}.png`}
-          />
-        </div>
-      )}
-    </div>
-  );
-}
-```
-
-```css
-/* components/PokemonView.module.css */
-.back-btn {
-  background-color: white;
-  border-radius: 10px;
-  padding: 7px 15px;
-  color: black;
-  text-decoration: none;
-  border: solid #f0f0f0 1px;
-  font-size: 20px;
-}
-
-.back-btn:hover {
-  box-shadow: rgba(100, 100, 111, 0.2) 0px 7px 29px 0px;
-}
-
-.pokemon {
-  display: flex;
-  justify-content: space-between;
-  margin-top: 20px;
-}
-
-.name {
-  font-size: 50px;
-  font-weight: 700;
-}
-
-.pokemon img {
-  width: 400px;
-}
-
-.spec {
-  display: flex;
-  font-size: 18px;
-  margin-top: 10px;
-}
-
-.label {
-  font-weight: 700;
-}
-```
-
-## Error handling
-
-With the current setup all the routes always return a `200 Success` http status no matter the response type.
-
-In order to return a more meaningful status code to the browser the `Props` struct can be initialized with also the
-`Props::new_with_status()` method.
-
-Let's see how it works!
-
-```diff
-// src/routes/pokemons/[pokemon].rs
-++ use reqwest::StatusCode;
-use serde::{Deserialize, Serialize};
-use tuono_lib::{Props, Request, Response};
-
-const POKEMON_API: &str = "https://pokeapi.co/api/v2/pokemon";
-
-#[derive(Debug, Serialize, Deserialize)]
-struct Pokemon {
-    name: String,
-    id: u16,
-    weight: u16,
-    height: u16,
-}
-
-#[tuono_lib::handler]
-async fn get_pokemon(req: Request<'_>, fetch: reqwest::Client) -> Response {
-    // The param `pokemon` is defined in the route filename [pokemon].rs
-    let pokemon = req.params.get("pokemon").unwrap();
-
-    return match fetch.get(format!("{POKEMON_API}/{pokemon}")).send().await {
-        Ok(res) => {
-++            if res.status() == StatusCode::NOT_FOUND {
-++                return Response::Props(Props::new_with_status("{}", StatusCode::NOT_FOUND));
-++             }
-
-            let data = res.json::<Pokemon>().await.unwrap();
-            Response::Props(Props::new(data))
-        }
---        Err(_err) => Response::Props(Props::new(
-++        Err(_err) => Response::Props(Props::new_with_status(
-++            "{}",
-++            StatusCode::INTERNAL_SERVER_ERROR,
-        )),
-    };
-}
-```
-
-```diff
-// src/routes/index.rs
-++ use reqwest::StatusCode;
-use serde::{Deserialize, Serialize};
-use tuono_lib::{Props, Request, Response};
-
-const ALL_POKEMON: &str = "https://pokeapi.co/api/v2/pokemon?limit=151";
-
-#[derive(Debug, Serialize, Deserialize)]
-struct Pokemons {
-    results: Vec<Pokemon>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct Pokemon {
-    name: String,
-    url: String,
-}
-
-#[tuono_lib::handler]
-async fn get_all_pokemons(_req: Request<'_>, fetch: reqwest::Client) -> Response {
-    return match fetch.get(ALL_POKEMON).send().await {
-        Ok(res) => {
-            let data = res.json::<Pokemons>().await.unwrap();
-            Response::Props(Props::new(data))
-        }
---        Err(_err) => Response::Props(Props::new(
-++        Err(_err) => Response::Props(Props::new_with_status(
-++            "{}", // Return empty JSON
-++            StatusCode::INTERNAL_SERVER_ERROR,
-        )),
-    };
-}
-```
-
-If you now try to load a not existing pokemon (`http://localhost:3000/pokemons/tuono-pokemon`) you will 
-correctly receive a 404 status code in the console.
-
-## Building for production
-
-The source now is ready to be released. Both server and client have been managed in a unoptimized way
-to easy the development experience. To build the project to the production state just run:
-
-```shell
-$ tuono build
-```
-
-This command just created the final assets within the `out` directory. To run then the prodiction server
-run:
-
-```shell
-$ cargo run --release
-```
-
-Check again [`http://localhost:3000/`](http://localhost:3000/) - This environment now has all the
-optimizations ready to unleash the power of a rust server that seamessly renders a React application!🚀
-
-> Note: The `out` directory is not standalone. You can't rely just on it to run the production server.
-
-## Conclusion
-
-That’s it! You just created a multi thread full stack application with rust and react. 
-
-The project is still under heavy development and many features are not ready yet but 
-I hope you got the taste of what is like working with rust and react in the same stack.
-
-As I mentioned in the introduction I'd love to hear what you thought about the framework and the tutorial - feel free to reach me 
-at [valerioageno@yahoo.it](mailto:valerioageno@yahoo.it) or in Twitter (X) DMs [@valerioageno](https://twitter.com/valerioageno).

e2e/e2e-test-setup.js

@@ -0,0 +1,8 @@
+import { execSync } from 'child_process'
+import path from 'path'
+
+const __dirname = import.meta.dirname
+const rootDir = path.join(__dirname, '..')
+
+execSync('cargo build --config opt-level=0', { cwd: rootDir, stdio: 'inherit' })
+execSync('turbo build', { stdio: 'inherit' })

e2e/fixtures/base/.gitignore

@@ -0,0 +1,20 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+.tuono
+out
+target
+
+# Playwright
+/test-results/
+/playwright-report/
+/blob-report/
+/playwright/.cache/
+