chore: update version to v0.17.8 (#559)

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

.editorconfig

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

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

@@ -1,23 +0,0 @@
-## Description
-A clear and concise description of what the bug is.
-
-## Expected behaviour
-A clear and concise description of what you expected to happen.
-
-## How to reproduce
-Steps to reproduce the behavior:
-
-## Screenshots
-If applicable, add screenshots to help explain your problem.
-
-## Tooling and environment
- - Tuono version [e.g. 0.4.0]
- - OS: [e.g. MacOS, Windows]
- - Browser: [e.g. chrome, safari]
- - Node version: [e.g. 20.0.0]
- - Rust version: [e.g. 1.79.0]
- - Crate version: [e.g. 1.78.0]
- - Node Package Manger version: [e.g. pnpm: 9.5.0] 
-
-## Additional context
-Add any other context about the problem here.

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

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

.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,32 @@
+# @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:
+          [
+            '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:
+          [
+            '.npmrc',
+            '.nvmrc',
+            '.prettierrc',
+            '.prettierignore',
+            'renovate.json',
+            'turbo.json',
+          ]

.github/pull_request_template.md

@@ -1,18 +1,24 @@
-## Context
-
 <!--
-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.
+👋 Thank you for your Pull Request 🙏
 -->
 
-## Description
+### 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
 
 <!--
-Thank you for your Pull Request. Please provide a description above and review
-the requirements below.
 
-Bug fixes and new features should include tests.
+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.
 
-Contributors guide: https://github.com/Valerioageno/tuono/blob/main/CONTRIBUTING.md
 -->

.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/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:check
+
+  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 format:check
+
+      - name: Lint
+        run: pnpm lint
+
+      - name: Types
+        run: pnpm types
+
+  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.13.1

.prettierignore

@@ -0,0 +1,8 @@
+pnpm-lock.yaml
+
+dist
+.tuono
+
+vite.config.ts.timestamp-*
+
+packages/tuono-lazy-fn-vite-plugin/tests/sources/*

.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/mdx",
-		"examples/tuono",
-		"examples/tutorial"
+  "examples/with-mdx",
+  "examples/tuono-app",
+  "examples/tuono-tutorial",
+  "examples/with-tailwind",
+  "e2e/fixtures/base",
 ]

README.md

@@ -1,98 +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>
-<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
-- ⌨️ MDX support
-- ⚙️   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 the CLI that provides all the needed commands to handle the fullstack project. 
-To download it is required [cargo](https://doc.rust-lang.org/cargo/) which is the [rust](https://www.rust-lang.org/)
-package manager.
-
-Then run `cargo install tuono`.
-
-To list all the available commands run `tuono -h`
-
-To create a new project run `tuono new [NAME]` (optionally you can pass the `--template` (or `-t`) 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 in the `production` mode.
-
-Now to execute it just run `cargo run --release`.
-
-## Requirements
-
-- rust
-- cargo
-- node
-- npm/pnpm/yarn*
-
-> yarn [pnp](https://yarnpkg.com/features/pnp) is not supported yet
-
-## 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,18 +1,16 @@
 [package]
 name = "tuono"
-version = "0.8.2"
+version = "0.17.8"
 edition = "2021"
 authors = ["V. Ageno <valerioageno@yahoo.it>"]
-description = "The react/rust fullstack framework"
-keywords = [ "react", "typescript", "fullstack", "web", "ssr"]
-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"]
-include = [
-		"src/*.rs",
-		"Cargo.toml"
-]
+include = ["src/*.rs", "Cargo.toml"]
 
 [lib]
 name = "tuono"
@@ -20,15 +18,23 @@ path = "src/lib.rs"
 
 [dependencies]
 clap = { version = "4.5.4", features = ["derive", "cargo"] }
-watchexec = "4.0.0"
+watchexec = "5.0.0"
 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.17.8"}
+spinners = "4.1.1"
+console = "0.15.10"
 
+[dev-dependencies]
+tempfile = "3.14.0"
+assert_cmd = "2.0.16"
+serial_test = "0.10.0"

crates/tuono/src/app.rs

@@ -1,29 +1,65 @@
+use crate::mode::Mode;
 use glob::glob;
 use glob::GlobError;
+use http::Method;
+use std::collections::hash_set::HashSet;
 use std::collections::{hash_map::Entry, HashMap};
+use std::fs::File;
+use std::io::prelude::*;
+use std::io::BufReader;
+use std::path::Path;
 use std::path::PathBuf;
 use std::process::Child;
 use std::process::Command;
 use std::process::Stdio;
+use tuono_internal::config::Config;
 
 use crate::route::Route;
 
 const IGNORE_EXTENSIONS: [&str; 3] = ["css", "scss", "sass"];
-const IGNORE_FILES: [&str; 1] = ["__root"];
+const IGNORE_FILES: [&str; 1] = ["__layout"];
 
-#[derive(Debug)]
+#[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().unwrap();
+        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: base_path.clone(),
+            has_app_state: has_app_state(base_path).unwrap_or(false),
+            config: None,
         };
 
         app.collect_routes();
@@ -32,18 +68,31 @@ impl App {
     }
 
     fn collect_routes(&mut self) {
-        glob(self.base_path.join("src/routes/**/*.*").to_str().unwrap())
-            .expect("Failed to read glob pattern")
-            .for_each(|entry| {
-                if self.should_collect_route(&entry) {
-                    self.collect_route(entry)
-                }
-            })
+        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().unwrap();
-        let file_name = entry.as_ref().unwrap().file_stem().unwrap();
+        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;
@@ -56,16 +105,23 @@ impl App {
     }
 
     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 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()
-            .unwrap()
-            .replace(&format!("{base_path_str}/src/routes"), "")
+            .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().unwrap() == "rs" {
+        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();
@@ -86,10 +142,51 @@ impl App {
         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) {
-        Command::new("./node_modules/.bin/tuono-build-prod")
+        if !Path::new(BUILD_JS_SCRIPT).exists() {
+            eprintln!("Failed to find the build script. Please run `npm install`");
+            std::process::exit(1);
+        }
+        let output = Command::new(BUILD_JS_SCRIPT)
             .output()
             .expect("Failed to build the react source");
+        if !output.status.success() {
+            eprintln!("Failed to build the react source");
+            eprintln!("Error: {}", String::from_utf8_lossy(&output.stderr));
+            std::process::exit(1);
+        }
     }
 
     pub fn run_rust_server(&self) -> Child {
@@ -101,6 +198,44 @@ impl App {
             .spawn()
             .expect("Failed to run the rust server")
     }
+
+    pub fn build_tuono_config(&mut self) -> Result<std::process::Output, std::io::Error> {
+        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();
+
+        if let Ok(config) = Config::get() {
+            self.config = Some(config);
+        } else {
+            eprintln!("[CLI] Failed to read tuono.config.ts");
+            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)]
@@ -111,14 +246,36 @@ mod tests {
     #[test]
     fn should_collect_routes() {
         let mut app = App::new();
-        app.base_path = "/home/user/Documents/tuono".into();
+        #[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
@@ -130,7 +287,13 @@ mod tests {
             ("/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)| {
@@ -150,8 +313,25 @@ mod tests {
     #[test]
     fn should_create_multi_level_axum_paths() {
         let mut app = App::new();
-        app.base_path = "/home/user/Documents/tuono".into();
 
+        #[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",
@@ -176,7 +356,7 @@ mod tests {
             assert_eq!(
                 app.route_map
                     .get(path)
-                    .unwrap()
+                    .expect("Failed to get route path")
                     .axum_info
                     .as_ref()
                     .unwrap()
@@ -212,8 +392,8 @@ mod tests {
         app.base_path = "/home/user/Documents/tuono".into();
 
         let routes = [
-            "/home/user/Documents/tuono/src/routes/__root.tsx",
-            "/home/user/Documents/tuono/src/routes/posts/__root.tsx",
+            "/home/user/Documents/tuono/src/routes/__layout.tsx",
+            "/home/user/Documents/tuono/src/routes/posts/__layout.tsx",
         ];
 
         routes.into_iter().for_each(|route| {
@@ -228,8 +408,23 @@ mod tests {
     #[test]
     fn should_correctly_parse_routes_with_server_handler() {
         let mut app = App::new();
-        app.base_path = "/home/user/Documents/tuono".into();
 
+        #[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",
@@ -246,9 +441,19 @@ mod tests {
             .into_iter()
             .for_each(|(path, expected_has_server_handler)| {
                 if expected_has_server_handler {
-                    assert!(app.route_map.get(path).unwrap().axum_info.is_some())
+                    assert!(app
+                        .route_map
+                        .get(path)
+                        .expect("Failed to get route path")
+                        .axum_info
+                        .is_some())
                 } else {
-                    assert!(app.route_map.get(path).unwrap().axum_info.is_none())
+                    assert!(app
+                        .route_map
+                        .get(path)
+                        .expect("Failed to get route path")
+                        .axum_info
+                        .is_none())
                 }
             })
     }

crates/tuono/src/cli.rs

@@ -20,6 +20,10 @@ enum Actions {
         #[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 {
@@ -29,22 +33,33 @@ enum Actions {
         /// 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 fullstack framework")]
+#[command(version, about = "The React/Rust full-stack framework")]
 struct Args {
     #[command(subcommand)]
     action: Actions,
 }
 
-fn init_tuono_folder(mode: Mode) -> std::io::Result<()> {
+fn check_for_tuono_config() {
+    if !PathBuf::from("tuono.config.ts").exists() {
+        eprintln!("Cannot find tuono.config.ts - is this a tuono project?");
+        std::process::exit(1);
+    }
+}
+
+fn init_tuono_folder(mode: Mode) -> std::io::Result<App> {
+    check_for_tuono_config();
     check_tuono_folder()?;
-    bundle_axum_source(mode)?;
+    let app = bundle_axum_source(mode)?;
     create_client_entry_files()?;
 
-    Ok(())
+    Ok(app)
 }
 
 pub fn app() -> std::io::Result<()> {
@@ -52,12 +67,22 @@ pub fn app() -> std::io::Result<()> {
 
     match args.action {
         Actions::Dev => {
-            init_tuono_folder(Mode::Dev)?;
+            let mut app = init_tuono_folder(Mode::Dev)?;
+
+            app.build_tuono_config()
+                .expect("Failed to build tuono.config.ts");
+
+            app.check_server_availability(Mode::Dev);
+
             watch::watch().unwrap();
         }
-        Actions::Build { ssg } => {
-            init_tuono_folder(Mode::Prod)?;
-            let app = App::new();
+        Actions::Build { ssg, no_js_emit } => {
+            let mut app = init_tuono_folder(Mode::Prod)?;
+
+            if no_js_emit {
+                println!("Rust build successfully finished");
+                return Ok(());
+            }
 
             if ssg && app.has_dynamic_routes() {
                 // TODO: allow dynamic routes static generation
@@ -65,6 +90,11 @@ pub fn app() -> std::io::Result<()> {
                 return Ok(());
             }
 
+            app.build_tuono_config()
+                .expect("Failed to build tuono.config.ts");
+
+            app.check_server_availability(Mode::Prod);
+
             app.build_react_prod();
 
             if ssg {
@@ -86,6 +116,8 @@ pub fn app() -> std::io::Result<()> {
                 )
                 .expect("Failed to clone assets into static output folder");
 
+                // the process is killed below so we don't really need to use wait() function
+                #[allow(clippy::zombie_processes)]
                 let mut rust_server = app.run_rust_server();
 
                 let reqwest = reqwest::blocking::Client::builder()
@@ -96,17 +128,21 @@ pub fn app() -> std::io::Result<()> {
                 // Wait for server
                 let mut is_server_ready = false;
 
+                let config = app.config.as_ref().unwrap();
+
                 while !is_server_ready {
-                    if reqwest.get("http://localhost:3000").send().is_ok() {
+                    let server_url =
+                        format!("http://{}:{}", config.server.host, config.server.port);
+                    if reqwest.get(server_url).send().is_ok() {
                         is_server_ready = true
                     }
                     // TODO: add maximum tries
                     sleep(Duration::from_secs(1))
                 }
 
-                app.route_map
-                    .iter()
-                    .for_each(|(_, route)| route.save_ssg_html(&reqwest));
+                for (_, route) in app.route_map {
+                    route.save_ssg_file(&reqwest)
+                }
 
                 // Close server
                 let _ = rust_server.kill();
@@ -117,8 +153,9 @@ pub fn app() -> std::io::Result<()> {
         Actions::New {
             folder_name,
             template,
+            head,
         } => {
-            scaffold_project::create_new_project(folder_name, template);
+            scaffold_project::create_new_project(folder_name, template, head);
         }
     }
 

crates/tuono/src/lib.rs

@@ -1,3 +1,8 @@
+//! ## 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 mode;

crates/tuono/src/mode.rs

@@ -1,4 +1,4 @@
-#[derive(PartialEq, Eq)]
+#[derive(PartialEq, Eq, Debug, Clone)]
 pub enum Mode {
     Prod,
     Dev,

crates/tuono/src/route.rs

@@ -1,17 +1,19 @@
 use fs_extra::dir::create_all;
+use http::Method;
 use regex::Regex;
 use reqwest::blocking::Client;
 use reqwest::Url;
 use std::fs::File;
 use std::io;
 use std::path::PathBuf;
+use std::str::FromStr;
 
 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)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub struct AxumInfo {
     // Path for importing the module
     pub module_import: String,
@@ -20,44 +22,105 @@ pub struct AxumInfo {
 }
 
 impl AxumInfo {
-    pub fn new(path: String) -> Self {
+    pub fn new(route: &Route) -> Self {
         // Remove first slash
-        let mut module = path.chars();
+        let mut module = route.path.chars();
         module.next();
 
-        let axum_route = path.replace("/index", "");
+        let axum_route = route.path.replace("/index", "");
+
+        let module_import = module
+            .as_str()
+            .to_string()
+            .replace('/', "_")
+            .replace('.', "_dot_")
+            .replace('-', "_hyphen_")
+            .to_lowercase();
 
         if axum_route.is_empty() {
             return AxumInfo {
-                module_import: module.as_str().to_string().replace('/', "_"),
+                module_import,
                 axum_route: "/".to_string(),
             };
         }
 
-        if has_dynamic_path(&path) {
+        if route.is_dynamic {
             return AxumInfo {
                 module_import: module
                     .as_str()
                     .to_string()
                     .replace('/', "_")
+                    .replace('-', "_hyphen_")
                     .replace('[', "dyn_")
+                    .replace("...", "catch_all_")
+                    .replace(']', ""),
+                axum_route: axum_route
+                    .replace("[...", "*")
+                    .replace('[', ":")
                     .replace(']', ""),
-                axum_route: axum_route.replace('[', ":").replace(']', ""),
             };
         }
 
         AxumInfo {
-            module_import: module.as_str().to_string().replace('/', "_").to_lowercase(),
+            module_import,
             axum_route,
         }
     }
 }
 
-#[derive(Debug, PartialEq, Eq)]
+// TODO: to be extended with common scenarios
+const NO_HTML_EXTENSIONS: [&str; 1] = ["xml"];
+
+// 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 {
@@ -66,14 +129,19 @@ impl Route {
             path: cleaned_path.clone(),
             axum_info: None,
             is_dynamic: has_dynamic_path(&cleaned_path),
+            api_data: ApiData::new(&cleaned_path),
         }
     }
 
-    pub fn update_axum_info(&mut self) {
-        self.axum_info = Some(AxumInfo::new(self.path.clone()))
+    pub fn is_api(&self) -> bool {
+        self.api_data.is_some()
     }
 
-    pub fn save_ssg_html(&self, reqwest: &Client) {
+    pub fn update_axum_info(&mut self) {
+        self.axum_info = Some(AxumInfo::new(self))
+    }
+
+    pub fn save_ssg_file(&self, reqwest: &Client) {
         let path = &self.path.replace("index", "");
 
         let mut response = reqwest
@@ -81,7 +149,7 @@ impl Route {
             .send()
             .unwrap();
 
-        let file_path = PathBuf::from(format!("out/static{}.html", &self.path));
+        let file_path = self.output_file_path();
 
         let parent_dir = file_path.parent().unwrap();
 
@@ -95,8 +163,7 @@ impl Route {
 
         // Saving also the server response
         if self.axum_info.is_some() {
-            let data_file_path =
-                PathBuf::from(&format!("out/static/__tuono/data{}/data.json", path));
+            let data_file_path = PathBuf::from(&format!("out/static/__tuono/data{path}"));
 
             let data_parent_dir = data_file_path.parent().unwrap();
 
@@ -105,11 +172,11 @@ impl Route {
                     .expect("Failed to create data parent directories");
             }
 
-            let base = Url::parse("http://localhost:3000/__tuono/data/data.json").unwrap();
+            let base = Url::parse("http://localhost:3000/__tuono/data").unwrap();
 
             let path = if path == "/" { "" } else { path };
 
-            let pathname = &format!("/__tuono/data{path}/data.json");
+            let pathname = &format!("/__tuono/data{path}");
 
             let url = base
                 .join(pathname)
@@ -123,6 +190,19 @@ impl Route {
             io::copy(&mut response, &mut data_file).expect("Failed to write the JSON on the file");
         }
     }
+
+    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)]
@@ -152,14 +232,33 @@ mod tests {
 
     #[test]
     fn should_correctly_create_the_axum_infos() {
-        let info = AxumInfo::new("/index".to_string());
+        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("/[posts]".to_string());
+        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"),
+            (
+                "/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,15 +1,18 @@
 use clap::crate_version;
 use reqwest::blocking;
+use reqwest::blocking::Client;
 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_TUONO_TAGS_URL: &str = "https://api.github.com/repos/tuono-labs/tuono/git/ref/tags/";
 
-const GITHUB_RAW_CONTENT_URL: &str = "https://raw.githubusercontent.com/Valerioageno/tuono/main/";
+const GITHUB_TUONO_TAG_COMMIT_TREES_URL: &str =
+    "https://api.github.com/repos/tuono-labs/tuono/git/trees/";
+
+const GITHUB_RAW_CONTENT_URL: &str = "https://raw.githubusercontent.com/tuono-labs/tuono";
 
 #[derive(Deserialize, Debug)]
 enum GithubFileType {
@@ -20,10 +23,25 @@ enum GithubFileType {
 }
 
 #[derive(Deserialize, Debug)]
-struct GithubResponse<T> {
+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,
@@ -32,42 +50,66 @@ struct GithubFile {
 }
 
 fn create_file(path: PathBuf, content: String) -> std::io::Result<()> {
-    let mut file = File::create(path)?;
+    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>) {
+pub fn create_new_project(
+    folder_name: Option<String>,
+    template: Option<String>,
+    select_head: Option<bool>,
+) {
     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 template = template.unwrap_or("tuono-app".to_string());
     let client = blocking::Client::builder()
         .user_agent("")
         .build()
-        .expect("Failed to build reqwest client");
+        .unwrap_or_else(|_| exit_with_error("Error: Failed to build request client"));
 
-    let res = client
-        .get(GITHUB_TUONO_REPO_URL)
+    // 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);
+
+    let res_tree = client
+        .get(tree_url)
         .send()
-        .expect("Failed to call the folder github API")
-        .json::<GithubResponse<GithubFile>>()
-        .expect("Failed to parse the repo structure");
+        .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
+    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() {
-        println!("Template not found: {template}");
-        return;
+        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();
     }
 
@@ -77,25 +119,33 @@ pub fn create_new_project(folder_name: Option<String>, template: Option<String>)
     let folder_path = current_dir.join(folder_name);
 
     create_directories(&new_project_files, &folder_path, &template)
-        .expect("Failed to create directories");
+        .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);
+
             let file_content = client
-                .get(format!("{GITHUB_RAW_CONTENT_URL}{path}"))
+                .get(url)
                 .send()
-                .expect("Failed to call the folder github API")
-                .text()
-                .expect("Failed to parse the repo structure");
+                .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);
 
-            create_file(file_path, file_content).expect("failed to create file");
+            if let Err(err) = create_file(file_path, file_content) {
+                exit_with_error(&format!("Failed to create file: {}", err));
+            }
         }
     }
 
@@ -104,6 +154,36 @@ pub fn create_new_project(folder_name: Option<String>, template: Option<String>)
     outro(folder);
 }
 
+fn generate_raw_content_url(select_head: Option<bool>, cli_version: &str, path: &String) -> String {
+    let tag = if select_head.unwrap_or(false) {
+        "main"
+    } else {
+        &format!("v{cli_version}")
+    };
+    format!("{}/{}/{}", GITHUB_RAW_CONTENT_URL, tag, path)
+}
+
+fn generate_tree_url(select_head: Option<bool>, client: &Client, cli_version: &str) -> String {
+    if select_head.unwrap_or(false) {
+        format!("{}main?recursive=1", GITHUB_TUONO_TAG_COMMIT_TREES_URL)
+    } else {
+        // This string does not include the "v" version prefix
+        let res_tag = client
+            .get(format!("{}v{}", GITHUB_TUONO_TAGS_URL, 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!(
+            "{}{}?recursive=1",
+            GITHUB_TUONO_TAG_COMMIT_TREES_URL, res_tag.object.sha
+        )
+    }
+}
+
 fn create_directories(
     new_project_files: &[&GithubFile],
     folder_path: &Path,
@@ -122,19 +202,23 @@ fn create_directories(
     }
     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 = 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)?;
+        .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())?;
+    file.write_all(package_json.as_bytes())
+        .unwrap_or_else(|err| {
+            exit_with_error(&format!("Failed to write to package.json: {}", err))
+        });
 
     Ok(())
 }
@@ -142,16 +226,21 @@ fn update_package_json_version(folder_path: &Path) -> io::Result<()> {
 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 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)?;
+        .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())?;
+    file.write_all(cargo_toml.as_bytes())
+        .unwrap_or_else(|err| exit_with_error(&format!("Failed to write to Cargo.toml: {}", err)));
 
     Ok(())
 }
@@ -170,3 +259,37 @@ fn outro(folder_name: String) {
     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!(
+            "{}/{}/{}",
+            GITHUB_RAW_CONTENT_URL, "main", "examples/tuono-app"
+        );
+        let generated = generate_raw_content_url(
+            Some(true),
+            crate_version!(),
+            &String::from("examples/tuono-app"),
+        );
+        assert_eq!(expected, generated)
+    }
+
+    #[test]
+    fn generate_valid_content_url_from_cli_version() {
+        let expected = format!(
+            "{}/{}/{}",
+            GITHUB_RAW_CONTENT_URL,
+            &format!("v{}", crate_version!()),
+            "examples/tuono-app"
+        );
+        let generated = generate_raw_content_url(
+            Some(false),
+            crate_version!(),
+            &String::from("examples/tuono-app"),
+        );
+        assert_eq!(expected, generated)
+    }
+}

crates/tuono/src/source_builder.rs

@@ -4,6 +4,8 @@ use std::io;
 use std::io::prelude::*;
 use std::path::Path;
 
+use clap::crate_version;
+
 use crate::app::App;
 use crate::mode::Mode;
 use crate::route::AxumInfo;
@@ -33,20 +35,27 @@ pub const AXUM_ENTRY_POINT: &str = r##"
 // File automatically generated
 // Do not manually change it
 
-use tuono_lib::{tokio, Mode, Server, axum::Router};
+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).start().await
+    Server::init(router, MODE).await.start().await
 }
 "##;
 
@@ -74,13 +83,22 @@ fn create_routes_declaration(routes: &HashMap<String, Route>) -> String {
                 module_import,
             } = axum_info.as_ref().unwrap();
 
-            route_declarations.push_str(&format!(
-                r#".route("{axum_route}", get({module_import}::route))"#
-            ));
-            let slash = if axum_route.ends_with('/') { "" } else { "/" };
-            route_declarations.push_str(&format!(
-                r#".route("/__tuono/data{axum_route}{slash}data.json", get({module_import}::api))"#
-            ));
+            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))"#
+                    ));
+                }
+            }
         }
     }
 
@@ -105,7 +123,7 @@ fn create_modules_declaration(routes: &HashMap<String, Route>) -> String {
     route_declarations
 }
 
-pub fn bundle_axum_source(mode: Mode) -> io::Result<()> {
+pub fn bundle_axum_source(mode: Mode) -> io::Result<App> {
     let base_path = std::env::current_dir().unwrap();
 
     let app = App::new();
@@ -114,7 +132,7 @@ pub fn bundle_axum_source(mode: Mode) -> io::Result<()> {
 
     create_main_file(&base_path, &bundled_file);
 
-    Ok(())
+    Ok(app)
 }
 
 fn generate_axum_source(app: &App, mode: Mode) -> String {
@@ -127,22 +145,45 @@ fn generate_axum_source(app: &App, mode: Mode) -> String {
             "// MODULE_IMPORTS\n",
             &create_modules_declaration(&app.route_map),
         )
-        .replace("/*MODE*/", mode.as_str());
-
-    let has_server_handlers = app
-        .route_map
-        .iter()
-        .filter(|(_, route)| route.axum_info.is_some())
-        .collect::<Vec<(&String, &Route)>>()
-        .is_empty();
-
-    if !has_server_handlers {
-        return src.replace(
-            "// AXUM_GET_ROUTE_HANDLER",
-            "use tuono_lib::axum::routing::get;",
+        .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
+
+    src.replace("// AXUM_GET_ROUTE_HANDLER", &import_http_handler)
 }
 
 pub fn check_tuono_folder() -> io::Result<()> {

crates/tuono/src/watch.rs

@@ -1,3 +1,4 @@
+use std::path::Path;
 use std::sync::Arc;
 use watchexec_supervisor::command::{Command, Program};
 
@@ -8,11 +9,27 @@ use watchexec_supervisor::job::{start_job, Job};
 
 use crate::mode::Mode;
 use crate::source_builder::bundle_axum_source;
+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: "node_modules/.bin/tuono-dev-watch".into(),
+            prog: DEV_WATCH_BIN_SRC.into(),
             args: vec![],
         },
         options: Default::default(),
@@ -20,7 +37,7 @@ fn watch_react_src() -> Job {
     .0
 }
 
-fn build_rust_src() -> Job {
+fn run_rust_dev_server() -> Job {
     start_job(Arc::new(Command {
         program: Program::Exec {
             prog: "cargo".into(),
@@ -31,10 +48,25 @@ fn build_rust_src() -> Job {
     .0
 }
 
-fn build_react_ssr_src() -> Job {
+fn build_rust_src() -> Job {
     start_job(Arc::new(Command {
         program: Program::Exec {
-            prog: "node_modules/.bin/tuono-dev-ssr".into(),
+            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(),
@@ -44,18 +76,28 @@ fn build_react_ssr_src() -> Job {
 
 #[tokio::main]
 pub async fn watch() -> Result<()> {
-    println!("Starting development environment...");
+    let term = Term::stdout();
+    let mut sp = Spinner::new(Spinners::Dots, "Starting dev server...".into());
+
     watch_react_src().start().await;
 
-    let run_server = build_rust_src();
+    let rust_server = run_rust_dev_server();
+    let build_rust_src = build_rust_src();
 
     let build_ssr_bundle = build_react_ssr_src();
 
     build_ssr_bundle.start().await;
+    build_rust_src.start().await;
 
-    run_server.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().unwrap();
 
     let wx = Watchexec::new(move |mut action| {
         let mut should_reload_ssr_bundle = false;
@@ -76,10 +118,10 @@ pub async fn watch() -> Result<()> {
         }
 
         if should_reload_rust_server {
-            println!("Reloading...");
-            run_server.stop();
-            bundle_axum_source(Mode::Dev).expect("Failed to bunlde rust source");
-            run_server.start();
+            println!("  Reloading...");
+            rust_server.stop();
+            bundle_axum_source(Mode::Dev).expect("Failed to bundle rust source");
+            rust_server.start();
         }
 
         if should_reload_ssr_bundle {

crates/tuono/tests/cli_build.rs

@@ -0,0 +1,202 @@
+mod utils;
+use assert_cmd::Command;
+use serial_test::serial;
+use std::fs;
+use utils::TempTuonoProject;
+
+const POST_API_FILE: &str = r"#[tuono_lib::api(POST)]";
+const GET_API_FILE: &str = r"#[tuono_lib::api(GET)]";
+
+#[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.");
+
+    dbg!(&temp_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("[CLI] Failed to read tuono.config.ts\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()
+        .stderr("Cannot find tuono.config.ts - is this a tuono project?\n");
+}
+
+#[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()
+        .stderr("Cannot find tuono.config.ts - is this a tuono project?\n");
+}

crates/tuono/tests/utils.rs

@@ -0,0 +1,69 @@
+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,
+}
+
+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.17.8"
+edition = "2021"
+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 = "0.10.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,24 @@
+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 port: u16,
+}
+
+#[derive(Deserialize, Serialize, Debug, Clone)]
+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))
+    }
+}

crates/tuono_internal/src/lib.rs

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

crates/tuono_internal/tests/config.rs

@@ -0,0 +1,50 @@
+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.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.to_owned())
+            .expect("Failed to restore the original directory.");
+    }
+}

crates/tuono_lib/Cargo.toml

@@ -1,11 +1,12 @@
 [package]
 name = "tuono_lib"
-version = "0.8.2"
+version = "0.17.8"
 edition = "2021"
 authors = ["V. Ageno <valerioageno@yahoo.it>"]
-description = "The react/rust fullstack framework"
+description = "Superfast React fullstack framework"
+homepage = "https://tuono.dev"
 keywords = [ "react", "typescript", "fullstack", "web", "ssr"]
-repository = "https://github.com/Valerioageno/tuono"
+repository = "https://github.com/tuono-labs/tuono"
 readme = "../../README.md"
 license-file = "../../LICENSE.md"
 categories = ["web-programming"]
@@ -14,13 +15,11 @@ include = [
 		"Cargo.toml"
 ]
 
-[lib]
-name = "tuono_lib"
-path = "src/lib.rs"
 
 [dependencies]
-ssr_rs = "0.5.5"
+ssr_rs = "0.8.1"
 axum = {version = "0.7.5", features = ["json", "ws"]}
+axum-extra = {version = "0.9.6", features = ["cookie"]}
 tokio = { version = "1.37.0", features = ["full"] }
 serde = { version = "1.0.202", features = ["derive"] }
 erased-serde = "0.4.5"
@@ -30,11 +29,20 @@ reqwest = {version = "0.12.4", features = ["json", "stream"]}
 once_cell = "1.19.0"
 regex = "1.10.5"
 either = "1.13.0"
-tower-http = {version = "0.5.2", features = ["fs"]}
+tower-http = {version = "0.6.0", features = ["fs"]}
+colored = "2.1.0"
 
-tuono_lib_macros = {path = "../tuono_lib_macros", version = "0.8.2"}
+tuono_lib_macros = {path = "../tuono_lib_macros", version = "0.17.8"}
+tuono_internal = {path = "../tuono_internal", version = "0.17.8"}
 # Match the same version used by axum
-tokio-tungstenite = "0.21.0"
+tokio-tungstenite = "0.24.0"
 futures-util = { version = "0.3", default-features = false, features = ["sink", "std"] }
-tungstenite = "0.23.0"
+tungstenite = "0.24.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 = "0.10.0"

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/lib.rs

@@ -1,4 +1,11 @@
+//! ## 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 logger;
 mod manifest;
 mod mode;
 mod payload;
@@ -13,10 +20,11 @@ pub use mode::Mode;
 pub use payload::Payload;
 pub use request::Request;
 pub use response::{Props, Response};
-pub use server::Server;
-pub use tuono_lib_macros::handler;
+pub use server::{tuono_internal_init_v8_platform, Server};
+pub use tuono_lib_macros::{api, handler};
 
 // Re-exports
 pub use axum;
-pub use reqwest;
+pub use axum_extra::extract::cookie;
+pub use ssr_rs::Ssr;
 pub use tokio;

crates/tuono_lib/src/logger.rs

@@ -0,0 +1,106 @@
+use colored::Colorize;
+use http::{method::Method, Request, Response};
+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/manifest.rs

@@ -29,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> {

crates/tuono_lib/src/payload.rs

@@ -1,8 +1,10 @@
+use crate::config::GLOBAL_CONFIG;
 use crate::manifest::MANIFEST;
 use crate::mode::{Mode, GLOBAL_MODE};
 use erased_serde::Serialize;
 use regex::Regex;
 use serde::Serialize as SerdeSerialize;
+use tuono_internal::config::ServerConfig;
 
 use crate::request::{Location, Request};
 
@@ -14,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: &'a Request, 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,
         }
     }
 
@@ -62,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);
 
@@ -84,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())
@@ -93,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;
                         }
@@ -168,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 {
@@ -194,11 +233,12 @@ mod tests {
         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,
         }
     }
 
@@ -274,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

@@ -34,7 +34,7 @@ impl From<Uri> for Location {
 
 #[derive(Debug, Clone)]
 pub struct Request {
-    uri: Uri,
+    pub uri: Uri,
     pub headers: HeaderMap,
     pub params: HashMap<String, String>,
 }

crates/tuono_lib/src/response.rs

@@ -1,18 +1,22 @@
 use crate::Request;
 use crate::{ssr::Js, Payload};
-use axum::http::StatusCode;
-use axum::response::{Html, IntoResponse, Redirect, Response as AxumResponse};
+use axum::http::{HeaderMap, StatusCode};
+use axum::response::{Html, IntoResponse, Redirect};
 use axum::Json;
+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)]
@@ -55,44 +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) -> AxumResponse {
+    pub fn render_to_string(&self, req: Request) -> impl IntoResponse {
         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::render_to_string(Some(&payload)) {
-                    Ok(html) => (*http_code, Html(html)).into_response(),
-                    Err(_) => {
-                        (*http_code, Html("500 Internal server error".to_string())).into_response()
-                    }
+                    Ok(html) => (*http_code, cookies.clone(), Html(html)),
+                    Err(_) => (
+                        *http_code,
+                        cookies.clone(),
+                        Html("500 Internal server error".to_string()),
+                    ),
                 }
+                .into_response()
             }
             Self::Redirect(to) => Redirect::permanent(to).into_response(),
+            Self::Custom(response) => response.clone().into_response(),
         }
     }
 
     pub fn json(&self) -> impl IntoResponse {
         match self {
-            Self::Props(Props { data, http_code }) => {
-                (*http_code, Json(JsonResponse::new(data))).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

@@ -1,63 +1,93 @@
-use crate::mode::{Mode, GLOBAL_MODE};
-
+use crate::config::GLOBAL_CONFIG;
 use crate::manifest::load_manifest;
+use crate::mode::{Mode, GLOBAL_MODE};
 use axum::routing::{get, Router};
+use colored::Colorize;
 use ssr_rs::Ssr;
 use tower_http::services::ServeDir;
+use tuono_internal::config::Config;
 
 use crate::{
-    catch_all::catch_all, vite_reverse_proxy::vite_reverse_proxy,
+    catch_all::catch_all, 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<reqwest::Client>,
+    router: Router,
     mode: Mode,
+    pub listener: tokio::net::TcpListener,
+    pub address: String,
 }
 
 impl Server {
-    pub fn init(router: Router<reqwest::Client>, mode: Mode) -> Server {
-        Ssr::create_platform();
+    pub async fn init(router: Router, mode: Mode) -> Server {
+        let config = Config::get().expect("[SERVER] Failed to load config");
 
-        GLOBAL_MODE.set(mode).unwrap();
+        let _ = GLOBAL_MODE.set(mode);
+        let _ = GLOBAL_CONFIG.set(config.clone());
 
         if mode == Mode::Prod {
             load_manifest()
         }
 
-        Server { router, mode }
+        let server_address = format!("{}:{}", config.server.host, config.server.port);
+
+        Server {
+            router,
+            mode,
+            address: server_address.clone(),
+            listener: tokio::net::TcpListener::bind(&server_address)
+                .await
+                .expect("[SERVER] Failed to bind to address"),
+        }
     }
 
-    pub async fn start(&self) {
-        let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
-
-        let fetch = reqwest::Client::new();
+    pub async fn start(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!("\nDevelopment app ready at http://localhost:3000/");
+            println!("  Ready at: {}\n", server_base_url.blue().bold());
             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)))
-                .with_state(fetch);
+                .fallback_service(
+                    ServeDir::new(DEV_PUBLIC_DIR)
+                        .fallback(get(catch_all).layer(LoggerLayer::new())),
+                );
 
-            axum::serve(listener, router)
+            axum::serve(self.listener, router)
                 .await
                 .expect("Failed to serve development server");
         } else {
-            println!("\nProduction app ready at http://localhost:3000/");
+            println!(
+                "  Production server at: {}\n",
+                server_base_url.blue().bold()
+            );
             let router = self
                 .router
                 .to_owned()
-                .fallback_service(ServeDir::new(PROD_PUBLIC_DIR).fallback(get(catch_all)))
-                .with_state(fetch);
+                .layer(LoggerLayer::new())
+                .fallback_service(
+                    ServeDir::new(PROD_PUBLIC_DIR)
+                        .fallback(get(catch_all).layer(LoggerLayer::new())),
+                );
 
-            axum::serve(listener, router)
+            axum::serve(self.listener, router)
                 .await
                 .expect("Failed to serve production server");
         }

crates/tuono_lib/src/ssr.rs

@@ -1,5 +1,5 @@
 use crate::mode::{Mode, GLOBAL_MODE};
-use ssr_rs::Ssr;
+use ssr_rs::{Ssr, SsrError};
 use std::cell::RefCell;
 use std::fs::read_to_string;
 use std::path::PathBuf;
@@ -9,8 +9,18 @@ use std::path::PathBuf;
 /// 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 {
-    pub fn render_to_string(payload: Option<&str>) -> Result<String, &'static str> {
+    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 {
@@ -27,7 +37,7 @@ impl ProdJs {
     thread_local! {
         pub static SSR: RefCell<Ssr<'static, 'static>> = RefCell::new(
                 Ssr::from(
-                    read_to_string(PathBuf::from("./out/server/prod-server.js")).expect("Server bundle not found"), ""
+                    read_to_string(PathBuf::from(PROD_BUNDLE_PATH)).expect("Server bundle not found"), ""
                     ).unwrap()
                 )
     }
@@ -36,10 +46,9 @@ impl ProdJs {
 struct DevJs;
 
 impl DevJs {
-    pub fn render_to_string(params: Option<&str>) -> Result<String, &'static str> {
+    pub fn render_to_string(params: Option<&str>) -> Result<String, SsrError> {
         Ssr::from(
-            read_to_string(PathBuf::from("./.tuono/server/dev-server.js"))
-                .expect("Server bundle not found"),
+            read_to_string(PathBuf::from(DEV_BUNDLE_PATH)).expect("Server bundle not found"),
             "",
         )
         .unwrap()

crates/tuono_lib/src/vite_reverse_proxy.rs

@@ -1,17 +1,25 @@
+use crate::config::GLOBAL_CONFIG;
 use axum::body::Body;
-use axum::extract::{Path, State};
+use axum::extract::Path;
 
 use axum::http::{HeaderName, HeaderValue};
 use axum::response::{IntoResponse, Response};
 use reqwest::Client;
 
-const VITE_URL: &str = "http://localhost:3001/vite-server";
+pub async fn vite_reverse_proxy(Path(path): Path<String>) -> impl IntoResponse {
+    let client = Client::new();
 
-pub async fn vite_reverse_proxy(
-    State(client): State<Client>,
-    Path(path): Path<String>,
-) -> impl IntoResponse {
-    match client.get(format!("{VITE_URL}/{path}")).send().await {
+    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());
 

crates/tuono_lib/src/vite_websocket_proxy.rs

@@ -1,3 +1,4 @@
+use crate::config::GLOBAL_CONFIG;
 use axum::extract::ws::{self, WebSocket, WebSocketUpgrade};
 use axum::response::IntoResponse;
 use futures_util::{SinkExt, StreamExt};
@@ -6,7 +7,6 @@ use tokio_tungstenite::tungstenite::{Error, Message};
 use tungstenite::client::IntoClientRequest;
 use tungstenite::ClientRequestBuilder;
 
-const VITE_WS: &str = "ws://localhost:3001/vite-server/";
 const VITE_WS_PROTOCOL: &str = "vite-hmr";
 
 /// This is the entry point to proxy the vite's WebSocket.
@@ -28,7 +28,17 @@ async fn handle_socket(mut tuono_socket: WebSocket) {
         return;
     }
 
-    let vite_ws_request = ClientRequestBuilder::new(VITE_WS.parse().unwrap())
+    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");

crates/tuono_lib/tests/main.rs

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

crates/tuono_lib/tests/server_test.rs

@@ -0,0 +1,105 @@
+mod utils;
+use crate::utils::utils::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}}"
+    );
+}

crates/tuono_lib/tests/utils/health_check.rs

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

crates/tuono_lib/tests/utils/mod.rs

@@ -0,0 +1,3 @@
+pub mod health_check;
+pub mod route;
+pub mod utils;

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/tests/utils/utils.rs

@@ -0,0 +1,106 @@
+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;
+use tuono_lib::{axum::Router, tuono_internal_init_v8_platform, Mode, Server};
+
+use crate::utils::health_check::get__tuono_internal_api as health_check;
+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,
+    )
+    .expect(
+        format!(
+            "Failed to create parent file directories: {}",
+            path.display()
+        )
+        .as_str(),
+    );
+
+    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": []}}"#,
+        );
+
+        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));
+
+        let server = Server::init(router, Mode::Prod).await;
+
+        let socket = server
+            .listener
+            .local_addr()
+            .expect("Failed to extract test server socket");
+
+        let _ = 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.to_owned())
+            .expect("Failed to restore the original directory.");
+    }
+}

crates/tuono_lib_macros/Cargo.toml

@@ -1,10 +1,11 @@
 [package]
 name = "tuono_lib_macros"
-version = "0.8.2"
+version = "0.17.8"
 edition = "2021"
-description = "The react/rust fullstack framework"
+description = "Superfast React fullstack framework"
+homepage = "https://tuono.dev"
 keywords = [ "react", "typescript", "fullstack", "web", "ssr"]
-repository = "https://github.com/Valerioageno/tuono"
+repository = "https://github.com/tuono-labs/tuono"
 readme = "../../README.md"
 license-file = "../../LICENSE.md"
 categories = ["web-programming"]
@@ -14,9 +15,8 @@ include = [
 ]
 
 [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,69 @@
+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::{parse_macro_input, FnArg, Ident, ItemFn, Pat};
+
+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());
+
+    quote! {
+        #application_state_import
+
+        #item
+
+        pub async fn #api_fn_name(#axum_arguments)#return_type {
+
+            #application_state_extractor
+
+           let pathname = request.uri();
+           let headers = request.headers();
+
+           let req = tuono_lib::Request::new(pathname.to_owned(), headers.to_owned(), params);
+
+           #fn_name(req.clone(), #argument_names).await
+        }
+    }
+    .into()
+}

crates/tuono_lib_macros/src/handler.rs

@@ -1,43 +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::{parse_macro_input, FnArg, ItemFn, Pat};
 
 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 tuono_lib::axum::response::IntoResponse;
-        use std::collections::HashMap;
-        use tuono_lib::axum::extract::{State, Path};
+        #application_state_import
 
         #item
 
-        pub async fn route(
-            Path(params): Path<HashMap<String, String>>,
-            State(client): State<tuono_lib::reqwest::Client>,
-            request: tuono_lib::axum::extract::Request
-        ) -> impl IntoResponse {
+        pub async fn tuono__internal__route(
+            #axum_arguments
+        ) -> impl tuono_lib::axum::response::IntoResponse {
+
+            #application_state_extractor
+
            let pathname = request.uri();
            let headers = request.headers();
 
            let req = tuono_lib::Request::new(pathname.to_owned(), headers.to_owned(), params);
 
-           #fn_name(req.clone(), client).await.render_to_string(req)
+           #fn_name(req.clone(), #argument_names).await.render_to_string(req)
         }
 
-        pub async fn api(
-            Path(params): Path<HashMap<String, String>>,
-            State(client): State<tuono_lib::reqwest::Client>,
-            request: tuono_lib::axum::extract::Request
-        ) -> impl IntoResponse{
+        pub async fn tuono__internal__api(
+            #axum_arguments
+        ) -> impl tuono_lib::axum::response::IntoResponse {
+
+            #application_state_extractor
+
            let pathname = request.uri();
            let headers = request.headers();
 
            let req = tuono_lib::Request::new(pathname.to_owned(), headers.to_owned(), params);
 
-           #fn_name(req.clone(), client).await.json()
+           #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::{parse2, parse_quote, FnArg, Pat, Stmt};
+
+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()
+}

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/README.md

@@ -1,12 +0,0 @@
-# Documentation
-
-This folder contains the documentation related to the `tuono` framework.
-
-The framework expects to enable SSG and MDX support in the next months. 
-At that time a standalone website will be built with tuono to hold the whole documentation.
-
-The following docs are currently actively maintained:
-- [tutorial](https://github.com/Valerioageno/tuono/blob/main/docs/tutorial.md)
-
-## Contributions
-Any help or suggestion will be strongly appreciated.

docs/tutorial.md

@@ -1,697 +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)
-* [Seo and meta tags](#seo-and-meta-tags)
-* [Handle redirections](#handle-redirections)
-* [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
-$ npm 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
-- Redirecting to a different route
-
-## 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::reqwest::Client;
-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: 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 `npm 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::reqwest::Client;
-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: 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 serde::{Deserialize, Serialize};
--- use tuono_lib::reqwest::Client;
-++ use tuono_lib::reqwest::{Client, StatusCode};
-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: 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 serde::{Deserialize, Serialize};
--- use tuono_lib::reqwest::Client;
-++ use tuono_lib::reqwest::{Client, StatusCode};
-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: 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.
-
-## Seo and meta tags
-
-The website now works and the http errors are meaningful but we should also take care to be meaningful
-for the web crawlers. The best way to do it is to enrich the meta tags like the `<title>` and the
-`<description>`.
-
-To do so `tuono` exposes also the `<Head />` component useful exactly for handling this scenario. Let's update the `/` and the
-`/pokemons/[pokemon]` routes with this.
-
-```diff
-// src/routes/index.tsx
-import type { TuonoProps } from "tuono";
-++ import { Head } from "tuono"
-
-interface Pokemon {
-  name: string
-}
-
-interface IndexProps {
-  results: Pokemon[]
-}
-
-export default function IndexPage({
-  data,
-}: TuonoProps<IndexProps>): JSX.Element {
-  if (!data?.results) {
-    return <></>;
-  }
-
-  return (
-    <>
-++    <Head>
-++      <title>Tuono tutorial</title>
-++    </Head>
-      <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>
-    </>
-  );
-}
-```
-
-```diff
-// src/routes/pokemons/[pokemon].tsx
--- import { TuonoProps } from "tuono";
-++ import { TuonoProps, Head } from "tuono";
-import PokemonView from "../../components/PokemonView";
-
-export default function Pokemon({ data }: TuonoProps): JSX.Element {
---  return <PokemonView pokemon={data} />;
-++  return (
-++        <>
-++            <Head>
-++                <title>Pokemon: ${data?.name}</title>
-++            </Head>
-++            <PokemonView pokemon={data} />
-++        </>
-++    )
-}
-```
-
-The `Head` component takes as children any valid HTML meta tag.
-
-## Handle redirections
-
-What if there is a pokemon among all of them that should be considered the GOAT? What
-we are going to do right now is creating a new route `/pokemons/GOAT` that points to the best
-pokemon of the first generation.
-
-First let's create a new route by just creating an new file `/pokemons/GOAT.rs` and pasting the following code:
-
-```rs
-// src/routes/pokemons/GOAT.rs
-use tuono_lib::{reqwest::Client, Request, Response};
-
-#[tuono_lib::handler]
-async fn redirect_to_goat(_: Request, _: Client) -> Response {
-    // Of course the GOAT is mewtwo - feel free to select your favourite 😉
-    Response::Redirect("/pokemons/mewtwo".to_string()) 
-}
-```
-
-Now let's create the button in the home page to actually point to it!
-
-```diff
-// src/routes/index.tsx
-
-<ul style={{ flexWrap: 'wrap', display: 'flex', gap: 10 }}>
-++      <PokemonLink pokemon={{ name: 'GOAT' }} id={0} />
-        {data.results.map((pokemon, i) => {
-          return <PokemonLink pokemon={pokemon} id={i + 1} key={i} />
-        })}
-</ul>
-```
-
-Now at [http://localhost:3000/](http:/localhost:3000/) you will find a new link at the beginning of the list.
-Click on it and see the application automatically redirecting you to your favourite pokemon's route!
-
-## 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/
+

e2e/fixtures/base/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "tuono"
+name = "tuono-app"
 version = "0.0.1"
 edition = "2021"
 
@@ -8,6 +8,6 @@ name = "tuono"
 path = ".tuono/main.rs"
 
 [dependencies]
-tuono_lib = { path = "../../crates/tuono_lib/"}
+tuono_lib = { path = "../../../crates/tuono_lib" } 
 serde = { version = "1.0.202", features = ["derive"] }
 

e2e/fixtures/base/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "fixture-base",
+  "type": "module",
+  "description": "Basic tuono application",
+  "version": "0.0.1",
+  "scripts": {
+    "test:e2e": "playwright test"
+  },
+  "dependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tuono": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.2",
+    "@types/react-dom": "^19.0.2",
+    "typescript": "^5.6.3"
+  }
+}

e2e/fixtures/base/playwright.config.ts

@@ -0,0 +1,26 @@
+import * as path from 'path'
+
+import { defineConfig } from '@playwright/test'
+
+const __dirname = import.meta.dirname
+
+const tuonoDir = path.join(__dirname, '../../../', 'target', 'debug', 'tuono')
+const setupScript = path.join(__dirname, '../..', 'e2e-test-setup.js')
+
+export default defineConfig({
+  testDir: './tests',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  webServer: {
+    command: `node ${setupScript} && ${tuonoDir} dev`,
+    port: 3000,
+    timeout: 420 * 1000,
+    stdout: 'pipe',
+    reuseExistingServer: false,
+  },
+  use: {
+    baseURL: 'http://localhost:3000',
+  },
+})

e2e/fixtures/base/src/routes/__layout.tsx

@@ -0,0 +1,17 @@
+import type { ReactNode, JSX } from 'react'
+import { TuonoScripts } from 'tuono'
+
+interface RootLayoutProps {
+  children: ReactNode
+}
+
+export default function RootLayout({ children }: RootLayoutProps): JSX.Element {
+  return (
+    <html>
+      <body>
+        <main>{children}</main>
+        <TuonoScripts />
+      </body>
+    </html>
+  )
+}

e2e/fixtures/base/src/routes/index.rs

@@ -0,0 +1,14 @@
+use serde::Serialize;
+use tuono_lib::{Props, Request, Response};
+
+#[derive(Serialize)]
+struct MyResponse<'a> {
+    subtitle: &'a str,
+}
+
+#[tuono_lib::handler]
+async fn get_server_side_props(_req: Request) -> Response {
+    Response::Props(Props::new(MyResponse {
+        subtitle: "Subtitle received from the server",
+    }))
+}

e2e/fixtures/base/src/routes/index.tsx

@@ -0,0 +1,24 @@
+import type { JSX } from 'react'
+import type { TuonoProps } from 'tuono'
+import { Link } from 'tuono'
+
+interface IndexProps {
+  subtitle: string
+}
+
+export default function IndexPage({
+  data,
+  isLoading,
+}: TuonoProps<IndexProps>): JSX.Element {
+  if (isLoading) {
+    return <h1>Loading...</h1>
+  }
+
+  return (
+    <>
+      <h1>TUONO</h1>
+      <h2>{data?.subtitle}</h2>
+      <Link href={'/second-route'}>Routing link</Link>)
+    </>
+  )
+}

e2e/fixtures/base/src/routes/second-route/index.tsx

@@ -0,0 +1,5 @@
+import type { JSX } from 'react'
+
+export default function SecondRoute(): JSX.Element {
+  return <h1>Second route</h1>
+}

e2e/fixtures/base/tests/e2e.spec.ts

@@ -0,0 +1,23 @@
+import { test, expect } from '@playwright/test'
+
+test('it renders index page', async ({ page }) => {
+  await page.goto('/')
+  const header = await page.textContent('h1')
+  const subtitle = await page.textContent('h2')
+  expect(header).toContain('TUONO')
+  expect(subtitle).toContain('Subtitle received from the server')
+})
+
+test('it renders second route', async ({ page }) => {
+  await page.goto('/second-route')
+  const header = await page.textContent('h1')
+  expect(header).toContain('Second route')
+})
+
+test('it routes to second route on link click', async ({ page }) => {
+  await page.goto('/')
+  await page.click('text=Routing link')
+  await page.waitForURL('/second-route')
+  const header = await page.textContent('h1')
+  expect(header).toContain('Second route')
+})

e2e/fixtures/base/tsconfig.json

@@ -20,6 +20,5 @@
     "noUnusedParameters": true,
     "noFallthroughCasesInSwitch": true
   },
-  "include": ["src"],
-  "references": [{ "path": "./tsconfig.node.json" }]
+  "include": ["src", "tuono.config.ts"]
 }

e2e/fixtures/base/tuono.config.ts

@@ -0,0 +1,5 @@
+import type { TuonoConfig } from 'tuono/config'
+
+const config: TuonoConfig = {}
+
+export default config

eslint.config.js

@@ -0,0 +1,168 @@
+import eslint from '@eslint/js'
+import tseslint from 'typescript-eslint'
+// @ts-expect-error no types are available for this plugin
+import eslintPluginImport from 'eslint-plugin-import'
+import eslintPluginReact from 'eslint-plugin-react'
+// @ts-expect-error no types are available for this plugin
+import eslintPluginReactHooks from 'eslint-plugin-react-hooks'
+
+/** @type import('typescript-eslint').ConfigArray */
+const tuonoEslintConfig = tseslint.config(
+  {
+    ignores: [
+      // #region shared
+      '**/dist',
+      '**/out',
+      '**/.tuono',
+      '**/vite.config.ts.timestamp**',
+      // #endregion shared
+
+      // #region package-specific
+      'packages/tuono-fs-router-vite-plugin/tests/generator/**',
+
+      'packages/tuono-lazy-fn-vite-plugin/tests/sources/**',
+
+      'packages/tuono/bin/**',
+      // #endregion package-specific
+
+      'examples/**',
+    ],
+  },
+  {
+    linterOptions: {
+      reportUnusedDisableDirectives: 'error',
+    },
+  },
+
+  eslint.configs.recommended,
+
+  /* eslint-disable @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access */
+  eslintPluginImport.flatConfigs.recommended,
+  eslintPluginImport.flatConfigs.typescript,
+  /* eslint-enable @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access */
+
+  // eslint-disable-next-line import/no-named-as-default-member
+  tseslint.configs.strictTypeChecked,
+
+  // @ts-expect-error flat is optional but always defined on runtime
+  eslintPluginReact.configs.flat.recommended,
+  eslintPluginReact.configs.flat['jsx-runtime'],
+
+  {
+    files: ['**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}'],
+    plugins: {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      'react-hooks': eslintPluginReactHooks,
+    },
+    rules: {
+      'react-hooks/rules-of-hooks': 'error',
+      'react-hooks/exhaustive-deps': 'error',
+    },
+  },
+
+  {
+    languageOptions: {
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+    settings: {
+      'import/parsers': {
+        '@typescript-eslint/parser': ['.ts', '.tsx'],
+      },
+      'import/resolver': {
+        typescript: true,
+      },
+      react: {
+        version: 'detect',
+      },
+    },
+    rules: {
+      // #region @typescript-eslint
+      '@typescript-eslint/array-type': ['error', { default: 'generic' }],
+      '@typescript-eslint/consistent-type-definitions': 'error',
+      '@typescript-eslint/consistent-type-imports': [
+        'error',
+        { prefer: 'type-imports' },
+      ],
+      '@typescript-eslint/explicit-module-boundary-types': 'error',
+      '@typescript-eslint/explicit-function-return-type': '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-inferrable-types': [
+        'error',
+        { ignoreParameters: true },
+      ],
+      '@typescript-eslint/restrict-template-expressions': [
+        'error',
+        {
+          allowAny: false,
+          allowBoolean: false,
+          allowNever: false,
+          allowNullish: false,
+          allowNumber: true,
+          allowRegExp: false,
+        },
+      ],
+      // #endregion @typescript-eslint
+
+      // #region import
+      'import/default': 'error',
+      'import/export': 'error',
+      'import/namespace': 'error',
+      'import/newline-after-import': 'error',
+      'import/no-cycle': 'error',
+      'import/no-duplicates': 'error',
+      'import/no-named-as-default-member': 'error',
+      'import/no-unused-modules': 'error',
+      'import/order': [
+        'error',
+        {
+          'newlines-between': 'always-and-inside-groups',
+          groups: [
+            'builtin',
+            'external',
+            'internal',
+            'parent',
+            'sibling',
+            'index',
+            'object',
+          ],
+        },
+      ],
+      // #endregion import
+
+      // #region misc
+      /**
+       * @todo some of this might be removed.
+       *       They are handled by other plugin and / or typescript
+       */
+      'no-case-declarations': 'error',
+      'no-empty': 'error',
+      'no-prototype-builtins': 'error',
+      'no-redeclare': 'error',
+      'no-shadow': 'error',
+      'no-undef': 'off',
+      'sort-imports': 'off',
+      // #endregion misc
+    },
+  },
+)
+
+export default tuonoEslintConfig

examples/README.md

@@ -4,25 +4,14 @@ This folder includes all the official tuono starters.
 
 To simply scaffold the base project run in your terminal:
 
-```shell
-$ tuono new [NAME]
+```sh
+tuono new [NAME]
 ```
 
 You can install any example included in this folder by just using the `--template` flag:
 
-```shell
-$ tuono new [NAME] --template [TEMPLATE] 
+```sh
+tuono new [NAME] --template [TEMPLATE] 
 ```
 
 `[TEMPLATE]` is the folder name.
-
-## Troubleshooting for contributors
-
-There is a common error that happens during example development due to 
-pnpm workspace about the findings of different react versions.
-
-To overcome this issue run within the single example folder:
-
-```
-pnpm install --ignore-workspace && pnpm upgrade --save
-```

examples/mdx/package.json

@@ -1,16 +0,0 @@
-{
-  "name": "tuono",
-  "description": "The react/rust fullstack framework",
-  "version": "0.0.1",
-  "dependencies": {
-    "@mdx-js/react": "^3.0.1",
-    "react": "18.3.1",
-    "react-dom": "18.3.1",
-    "tuono": "link:../../packages/tuono"
-  },
-  "devDependencies": {
-    "@types/react": "^18.3.3",
-    "@types/react-dom": "^18.3.0",
-    "typescript": "^5.5.3"
-  }
-}

examples/mdx/src/routes/__root.tsx

@@ -1,14 +0,0 @@
-import type { ReactNode } from 'react'
-import { MDXProvider } from '@mdx-js/react'
-
-interface RootRouteProps {
-  children: ReactNode
-}
-
-export default function RootRoute({ children }: RootRouteProps): JSX.Element {
-  return (
-    <main className="main">
-      <MDXProvider components={{}}>{children}</MDXProvider>
-    </main>
-  )
-}

examples/mdx/tsconfig.node.json

@@ -1,11 +0,0 @@
-{
-  "compilerOptions": {
-    "composite": true,
-    "skipLibCheck": true,
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "allowSyntheticDefaultImports": true,
-    "strict": true
-  },
-  "include": ["vite.config.ts"]
-}

examples/tuono-app/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "tuono"
+name = "tuono-app"
 version = "0.0.1"
 edition = "2021"
 
@@ -8,6 +8,6 @@ name = "tuono"
 path = ".tuono/main.rs"
 
 [dependencies]
-tuono_lib = { path = "../../crates/tuono_lib/"}
+tuono_lib = { path = "../../crates/tuono_lib/" }
 serde = { version = "1.0.202", features = ["derive"] }
 

examples/tuono-app/README.md

@@ -2,8 +2,8 @@
 
 This is the starter tuono project. To download it run in your terminal:
 
-```shell
-$ tuono new [NAME]
+```sh
+tuono new my-first-tuono-app
 ```
 
 

examples/tuono-app/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "tuono-app",
+  "description": "Basic tuono application",
+  "version": "0.0.1",
+  "dependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tuono": "link:../../packages/tuono"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.2",
+    "@types/react-dom": "^19.0.2",
+    "typescript": "^5.6.3"
+  }
+}