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,28 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: bug
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Desktop (please complete the following information):**
- - OS: [e.g. iOS]
- - Browser [e.g. chrome, safari]
- - Version [e.g. 22]
-
-**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,25 +1,24 @@
-## Description
-
 <!--
-Thank you for your Pull Request. Please provide a description above and review
-the requirements below.
-
-Bug fixes and new features should include tests.
-
-Contributors guide: https://github.com/Valerioageno/tuono/blob/main/CONTRIBUTING.md
+👋 Thank you for your Pull Request 🙏
 -->
 
-## Context
+### Checklist
+
+- [ ] I have read [Contributing > Pull requests](https://tuono.dev/documentation/contributing/pull-requests)
+
+### Related issue
+
+Fixes #0
+
+<!-- Replace the content with "None" if you haven't an issue to link -->
+
+### Overview
 
 <!--
-Explain the context and why you're making that change. What is the problem
-you're trying to solve? If a new feature is being added, describe the intended
-use case that feature fulfills.
--->
 
-## Solution
+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.
 
-<!--
-Summarize the solution and provide any necessary context needed to understand
-the code change.
 -->

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

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

crates/tuono/src/cli.rs

@@ -0,0 +1,163 @@
+use fs_extra::dir::{copy, CopyOptions};
+use std::path::PathBuf;
+use std::thread::sleep;
+use std::time::Duration;
+
+use clap::{Parser, Subcommand};
+
+use crate::app::App;
+use crate::mode::Mode;
+use crate::scaffold_project;
+use crate::source_builder::{bundle_axum_source, check_tuono_folder, create_client_entry_files};
+use crate::watch;
+
+#[derive(Subcommand, Debug)]
+enum Actions {
+    /// Start the development environment
+    Dev,
+    /// Build the production assets
+    Build {
+        #[arg(short, long = "static")]
+        /// Statically generate the website HTML
+        ssg: bool,
+
+        #[arg(short, long)]
+        /// Prevent to export the js assets
+        no_js_emit: bool,
+    },
+    /// Scaffold a new project
+    New {
+        /// The folder in which load the project. Default is the current directory.
+        folder_name: Option<String>,
+        /// The template to use to scaffold the project. The template should match one of the tuono
+        /// examples
+        #[arg(short, long)]
+        template: Option<String>,
+        /// Load the latest commit available on the main branch
+        #[arg(long)]
+        head: Option<bool>,
+    },
+}
+
+#[derive(Parser, Debug)]
+#[command(version, about = "The React/Rust full-stack framework")]
+struct Args {
+    #[command(subcommand)]
+    action: Actions,
+}
+
+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()?;
+    let app = bundle_axum_source(mode)?;
+    create_client_entry_files()?;
+
+    Ok(app)
+}
+
+pub fn app() -> std::io::Result<()> {
+    let args = Args::parse();
+
+    match args.action {
+        Actions::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, 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
+                println!("Cannot statically build dynamic routes");
+                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 {
+                println!("SSG: generation started");
+
+                let static_dir = PathBuf::from("out/static");
+
+                if static_dir.is_dir() {
+                    std::fs::remove_dir_all(&static_dir)
+                        .expect("Failed to clear the out/static folder");
+                }
+
+                std::fs::create_dir(&static_dir).expect("Failed to create static output dir");
+
+                copy(
+                    "./out/client",
+                    static_dir,
+                    &CopyOptions::new().overwrite(true).content_only(true),
+                )
+                .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()
+                    .user_agent("")
+                    .build()
+                    .expect("Failed to build reqwest client");
+
+                // Wait for server
+                let mut is_server_ready = false;
+
+                let config = app.config.as_ref().unwrap();
+
+                while !is_server_ready {
+                    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))
+                }
+
+                for (_, route) in app.route_map {
+                    route.save_ssg_file(&reqwest)
+                }
+
+                // Close server
+                let _ = rust_server.kill();
+            };
+
+            println!("Build successfully finished");
+        }
+        Actions::New {
+            folder_name,
+            template,
+            head,
+        } => {
+            scaffold_project::create_new_project(folder_name, template, head);
+        }
+    }
+
+    Ok(())
+}

crates/tuono/src/lib.rs

@@ -1,66 +1,12 @@
-use clap::{Parser, Subcommand};
-use std::process::Command;
-
-mod source_builder;
-use source_builder::{bundle_axum_source, create_client_entry_files};
-
-use crate::source_builder::{check_tuono_folder, Mode};
+//! ## 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;
+mod route;
 mod scaffold_project;
+mod source_builder;
 mod watch;
-
-#[derive(Subcommand, Debug)]
-enum Actions {
-    /// Start the development environment
-    Dev,
-    /// Build the production assets
-    Build,
-    /// Scaffold a new project
-    New {
-        /// The folder in which load the project. Default is the current directory.
-        folder_name: Option<String>,
-        /// The template to use to scaffold the project. The template should match one of the tuono
-        /// examples
-        #[arg(short, long)]
-        template: Option<String>,
-    },
-}
-
-#[derive(Parser, Debug)]
-#[command(version, about = "The react/rust fullstack framework")]
-struct Args {
-    #[command(subcommand)]
-    action: Actions,
-}
-
-fn init_tuono_folder(mode: Mode) -> std::io::Result<()> {
-    check_tuono_folder()?;
-    bundle_axum_source(mode)?;
-    create_client_entry_files()?;
-
-    Ok(())
-}
-
-pub fn cli() -> std::io::Result<()> {
-    let args = Args::parse();
-
-    match args.action {
-        Actions::Dev => {
-            init_tuono_folder(Mode::Dev)?;
-            watch::watch().unwrap();
-        }
-        Actions::Build => {
-            init_tuono_folder(Mode::Prod)?;
-            let mut vite_build = Command::new("./node_modules/.bin/tuono-build-prod");
-            let _ = &vite_build.output()?;
-        }
-        Actions::New {
-            folder_name,
-            template,
-        } => {
-            scaffold_project::create_new_project(folder_name, template);
-        }
-    }
-
-    Ok(())
-}

crates/tuono/src/main.rs

@@ -1,5 +1,5 @@
-use tuono::cli;
+use tuono::cli::app;
 
 fn main() {
-    cli().unwrap();
+    app().expect("Failed to start the CLI")
 }

crates/tuono/src/mode.rs

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

crates/tuono/src/route.rs

@@ -0,0 +1,264 @@
+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, Clone)]
+pub struct AxumInfo {
+    // Path for importing the module
+    pub module_import: String,
+    // path for the the axum router
+    pub axum_route: String,
+}
+
+impl AxumInfo {
+    pub fn new(route: &Route) -> Self {
+        // Remove first slash
+        let mut module = route.path.chars();
+        module.next();
+
+        let axum_route = 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,
+                axum_route: "/".to_string(),
+            };
+        }
+
+        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(']', ""),
+            };
+        }
+
+        AxumInfo {
+            module_import,
+            axum_route,
+        }
+    }
+}
+
+// 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 {
+    pub fn new(cleaned_path: String) -> Self {
+        Route {
+            path: cleaned_path.clone(),
+            axum_info: None,
+            is_dynamic: has_dynamic_path(&cleaned_path),
+            api_data: ApiData::new(&cleaned_path),
+        }
+    }
+
+    pub fn is_api(&self) -> bool {
+        self.api_data.is_some()
+    }
+
+    pub fn update_axum_info(&mut self) {
+        self.axum_info = Some(AxumInfo::new(self))
+    }
+
+    pub fn save_ssg_file(&self, reqwest: &Client) {
+        let path = &self.path.replace("index", "");
+
+        let mut response = reqwest
+            .get(format!("http://localhost:3000{path}"))
+            .send()
+            .unwrap();
+
+        let file_path = self.output_file_path();
+
+        let parent_dir = file_path.parent().unwrap();
+
+        if !parent_dir.is_dir() {
+            create_all(parent_dir, false).expect("Failed to create parent directories");
+        }
+
+        let mut file = File::create(file_path).expect("Failed to create the HTML file");
+
+        io::copy(&mut response, &mut file).expect("Failed to write the HTML on the file");
+
+        // Saving also the server response
+        if self.axum_info.is_some() {
+            let data_file_path = PathBuf::from(&format!("out/static/__tuono/data{path}"));
+
+            let data_parent_dir = data_file_path.parent().unwrap();
+
+            if !data_parent_dir.is_dir() {
+                create_all(data_parent_dir, false)
+                    .expect("Failed to create data parent directories");
+            }
+
+            let base = Url::parse("http://localhost:3000/__tuono/data").unwrap();
+
+            let path = if path == "/" { "" } else { path };
+
+            let pathname = &format!("/__tuono/data{path}");
+
+            let url = base
+                .join(pathname)
+                .expect("Failed to build the reqwest URL");
+
+            let mut response = reqwest.get(url).send().unwrap();
+
+            let mut data_file =
+                File::create(data_file_path).expect("Failed to create the JSON file");
+
+            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)]
+mod tests {
+
+    use super::*;
+
+    #[test]
+    fn should_find_dynamic_paths() {
+        let routes = [
+            ("/home/user/Documents/tuono/src/routes/about.rs", false),
+            ("/home/user/Documents/tuono/src/routes/index.rs", false),
+            (
+                "/home/user/Documents/tuono/src/routes/posts/index.rs",
+                false,
+            ),
+            (
+                "/home/user/Documents/tuono/src/routes/posts/[post].rs",
+                true,
+            ),
+        ];
+
+        routes
+            .into_iter()
+            .for_each(|route| assert_eq!(has_dynamic_path(route.0), route.1));
+    }
+
+    #[test]
+    fn should_correctly_create_the_axum_infos() {
+        let info = AxumInfo::new(&Route::new("/index".to_string()));
+
+        assert_eq!(info.axum_route, "/");
+        assert_eq!(info.module_import, "index");
+
+        let dyn_info = AxumInfo::new(&Route::new("/[posts]".to_string()));
+
+        assert_eq!(dyn_info.axum_route, "/:posts");
+        assert_eq!(dyn_info.module_import, "dyn_posts");
+    }
+
+    #[test]
+    fn should_define_the_correct_html_build_path() {
+        let routes = [
+            ("/index", "out/static/index.html"),
+            ("/documentation", "out/static/documentation/index.html"),
+            ("/sitemap.xml", "out/static/sitemap.xml"),
+            (
+                "/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

@@ -1,27 +1,15 @@
-use glob::glob;
-use glob::GlobError;
-use regex::Regex;
 use std::collections::HashMap;
 use std::fs;
 use std::io;
 use std::io::prelude::*;
 use std::path::Path;
-use std::path::PathBuf;
 
-#[derive(PartialEq, Eq)]
-pub enum Mode {
-    Prod,
-    Dev,
-}
+use clap::crate_version;
 
-impl Mode {
-    pub fn as_str<'a>(&self) -> &'a str {
-        if *self == Mode::Dev {
-            return "Mode::Dev";
-        }
-        "Mode::Prod"
-    }
-}
+use crate::app::App;
+use crate::mode::Mode;
+use crate::route::AxumInfo;
+use crate::route::Route;
 
 pub const SERVER_ENTRY_DATA: &str = "// File automatically generated by tuono
 // Do not manually update this file
@@ -47,107 +35,33 @@ pub const AXUM_ENTRY_POINT: &str = r##"
 // File automatically generated
 // Do not manually change it
 
-use tuono_lib::{tokio, Mode, Server, axum::Router, axum::routing::get};
+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
 }
 "##;
 
-const ROOT_FOLDER: &str = "src/routes";
+const ROUTE_FOLDER: &str = "src/routes";
 const DEV_FOLDER: &str = ".tuono";
 
-#[derive(Debug, PartialEq, Eq)]
-struct Route {
-    /// Every module import is the path with a _ instead of /
-    pub module_import: String,
-    pub axum_route: String,
-}
-
-fn has_dynamic_path(route: &str) -> bool {
-    let regex = Regex::new(r"\[(.*?)\]").expect("Failed to create the regex");
-    regex.is_match(route)
-}
-
-impl Route {
-    pub fn new(path: &str) -> Self {
-        let route_name = path.replace(".rs", "");
-        // Remove first slash
-        let mut module = route_name.as_str().chars();
-        module.next();
-
-        let axum_route = path.replace("/index.rs", "").replace(".rs", "");
-
-        if axum_route.is_empty() {
-            return Route {
-                module_import: module.as_str().to_string().replace('/', "_"),
-                axum_route: "/".to_string(),
-            };
-        }
-
-        if has_dynamic_path(&route_name) {
-            return Route {
-                module_import: module
-                    .as_str()
-                    .to_string()
-                    .replace('/', "_")
-                    .replace('[', "dyn_")
-                    .replace(']', ""),
-                axum_route: axum_route.replace('[', ":").replace(']', ""),
-            };
-        }
-
-        Route {
-            module_import: module.as_str().to_string().replace('/', "_").to_lowercase(),
-            axum_route,
-        }
-    }
-}
-
-struct SourceBuilder {
-    route_map: HashMap<PathBuf, Route>,
-    base_path: PathBuf,
-}
-
-impl SourceBuilder {
-    pub fn new() -> Self {
-        let base_path = std::env::current_dir().unwrap();
-
-        SourceBuilder {
-            route_map: HashMap::new(),
-            base_path,
-        }
-    }
-
-    fn collect_routes(&mut self) {
-        glob(self.base_path.join("src/routes/**/*.rs").to_str().unwrap())
-            .unwrap()
-            .for_each(|entry| self.collect_route(entry))
-    }
-
-    fn collect_route(&mut self, path_buf: Result<PathBuf, GlobError>) {
-        let entry = path_buf.unwrap();
-        let base_path_str = self.base_path.to_str().unwrap();
-        let path = entry
-            .to_str()
-            .unwrap()
-            .replace(&format!("{base_path_str}/src/routes"), "");
-
-        let route = Route::new(&path);
-
-        self.route_map.insert(PathBuf::from(path), route);
-    }
-}
-
 fn create_main_file(base_path: &Path, bundled_file: &String) {
     let mut data_file =
         fs::File::create(base_path.join(".tuono/main.rs")).expect("creation failed");
@@ -157,67 +71,119 @@ fn create_main_file(base_path: &Path, bundled_file: &String) {
         .expect("write failed");
 }
 
-fn create_routes_declaration(routes: &HashMap<PathBuf, Route>) -> String {
+fn create_routes_declaration(routes: &HashMap<String, Route>) -> String {
     let mut route_declarations = String::from("// ROUTE_BUILDER\n");
 
     for (_, route) in routes.iter() {
-        let Route {
-            axum_route,
-            module_import,
-        } = &route;
+        let Route { axum_info, .. } = &route;
 
-        route_declarations.push_str(&format!(
-            r#".route("{axum_route}", get({module_import}::route))"#
-        ));
-        route_declarations.push_str(&format!(
-            r#".route("/__tuono/data{axum_route}", get({module_import}::api))"#
-        ));
+        if axum_info.is_some() {
+            let AxumInfo {
+                axum_route,
+                module_import,
+            } = axum_info.as_ref().unwrap();
+
+            if !route.is_api() {
+                route_declarations.push_str(&format!(
+                    r#".route("{axum_route}", get({module_import}::tuono__internal__route))"#
+                ));
+
+                route_declarations.push_str(&format!(
+                    r#".route("/__tuono/data{axum_route}", get({module_import}::tuono__internal__api))"#
+                ));
+            } else {
+                for method in route.api_data.as_ref().unwrap().methods.clone() {
+                    let method = method.to_string().to_lowercase();
+                    route_declarations.push_str(&format!(
+                        r#".route("{axum_route}", {method}({module_import}::{method}__tuono_internal_api))"#
+                    ));
+                }
+            }
+        }
     }
 
     route_declarations
 }
 
-fn create_modules_declaration(routes: &HashMap<PathBuf, Route>) -> String {
+fn create_modules_declaration(routes: &HashMap<String, Route>) -> String {
     let mut route_declarations = String::from("// MODULE_IMPORTS\n");
 
     for (path, route) in routes.iter() {
-        let module_name = &route.module_import;
-        let path_str = path.to_str().unwrap();
-        route_declarations.push_str(&format!(
-            r#"#[path="../{ROOT_FOLDER}{path_str}"]
-mod {module_name};
-"#
-        ))
+        if route.axum_info.is_some() {
+            let AxumInfo { module_import, .. } = route.axum_info.as_ref().unwrap();
+
+            route_declarations.push_str(&format!(
+                r#"#[path="../{ROUTE_FOLDER}{path}.rs"]
+                    mod {module_import};
+                    "#
+            ))
+        }
     }
 
     route_declarations
 }
 
-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 mut source_builder = SourceBuilder::new();
+    let app = App::new();
 
-    source_builder.collect_routes();
-
-    let bundled_file = generate_axum_source(&source_builder, mode);
+    let bundled_file = generate_axum_source(&app, mode);
 
     create_main_file(&base_path, &bundled_file);
 
-    Ok(())
+    Ok(app)
 }
 
-fn generate_axum_source(source_builder: &SourceBuilder, mode: Mode) -> String {
-    AXUM_ENTRY_POINT
+fn generate_axum_source(app: &App, mode: Mode) -> String {
+    let src = AXUM_ENTRY_POINT
         .replace(
             "// ROUTE_BUILDER\n",
-            &create_routes_declaration(&source_builder.route_map),
+            &create_routes_declaration(&app.route_map),
         )
         .replace(
             "// MODULE_IMPORTS\n",
-            &create_modules_declaration(&source_builder.route_map),
+            &create_modules_declaration(&app.route_map),
         )
+        .replace("/*VERSION*/", crate_version!())
         .replace("/*MODE*/", mode.as_str())
+        .replace(
+            "//MAIN_FILE_IMPORT//",
+            if app.has_app_state {
+                r#"#[path="../src/app.rs"]
+                    mod tuono_main_state;
+                    "#
+            } else {
+                ""
+            },
+        )
+        .replace(
+            "//MAIN_FILE_DEFINITION//",
+            if app.has_app_state {
+                "let user_custom_state = tuono_main_state::main();"
+            } else {
+                ""
+            },
+        )
+        .replace(
+            "//MAIN_FILE_USAGE//",
+            if app.has_app_state {
+                ".with_state(user_custom_state)"
+            } else {
+                ""
+            },
+        );
+
+    let mut import_http_handler = String::new();
+
+    let used_http_methods = app.get_used_http_methods();
+
+    for method in used_http_methods.into_iter() {
+        let method = method.to_string().to_lowercase();
+        import_http_handler.push_str(&format!("use tuono_lib::axum::routing::{method};\n"))
+    }
+
+    src.replace("// AXUM_GET_ROUTE_HANDLER", &import_http_handler)
 }
 
 pub fn check_tuono_folder() -> io::Result<()> {
@@ -246,103 +212,9 @@ mod tests {
 
     use super::*;
 
-    #[test]
-    fn should_find_dynamic_paths() {
-        let routes = [
-            ("/home/user/Documents/tuono/src/routes/about.rs", false),
-            ("/home/user/Documents/tuono/src/routes/index.rs", false),
-            (
-                "/home/user/Documents/tuono/src/routes/posts/index.rs",
-                false,
-            ),
-            (
-                "/home/user/Documents/tuono/src/routes/posts/[post].rs",
-                true,
-            ),
-        ];
-
-        routes
-            .into_iter()
-            .for_each(|route| assert_eq!(has_dynamic_path(route.0), route.1));
-    }
-
-    #[test]
-    fn should_collect_routes() {
-        let mut source_builder = SourceBuilder::new();
-        source_builder.base_path = "/home/user/Documents/tuono".into();
-
-        let routes = [
-            "/home/user/Documents/tuono/src/routes/about.rs",
-            "/home/user/Documents/tuono/src/routes/index.rs",
-            "/home/user/Documents/tuono/src/routes/posts/index.rs",
-            "/home/user/Documents/tuono/src/routes/posts/[post].rs",
-            "/home/user/Documents/tuono/src/routes/posts/UPPERCASE.rs",
-        ];
-
-        routes
-            .into_iter()
-            .for_each(|route| source_builder.collect_route(Ok(PathBuf::from(route))));
-
-        let results = [
-            ("/index.rs", "index"),
-            ("/about.rs", "about"),
-            ("/posts/index.rs", "posts_index"),
-            ("/posts/[post].rs", "posts_dyn_post"),
-            ("/posts/UPPERCASE.rs", "posts_uppercase"),
-        ];
-
-        results.into_iter().for_each(|(path, module_import)| {
-            assert_eq!(
-                source_builder
-                    .route_map
-                    .get(&PathBuf::from(path))
-                    .unwrap()
-                    .module_import,
-                String::from(module_import)
-            )
-        })
-    }
-
-    #[test]
-    fn should_create_multi_level_axum_paths() {
-        let mut source_builder = SourceBuilder::new();
-        source_builder.base_path = "/home/user/Documents/tuono".into();
-
-        let routes = [
-            "/home/user/Documents/tuono/src/routes/about.rs",
-            "/home/user/Documents/tuono/src/routes/index.rs",
-            "/home/user/Documents/tuono/src/routes/posts/index.rs",
-            "/home/user/Documents/tuono/src/routes/posts/any-post.rs",
-            "/home/user/Documents/tuono/src/routes/posts/[post].rs",
-        ];
-
-        routes
-            .into_iter()
-            .for_each(|route| source_builder.collect_route(Ok(PathBuf::from(route))));
-
-        let results = [
-            ("/index.rs", "/"),
-            ("/about.rs", "/about"),
-            ("/posts/index.rs", "/posts"),
-            ("/posts/any-post.rs", "/posts/any-post"),
-            ("/posts/[post].rs", "/posts/:post"),
-        ];
-
-        results.into_iter().for_each(|(path, expected_path)| {
-            assert_eq!(
-                source_builder
-                    .route_map
-                    .get(&PathBuf::from(path))
-                    .unwrap()
-                    .axum_route,
-                String::from(expected_path)
-            )
-        })
-    }
-
     #[test]
     fn should_set_the_correct_mode() {
-        let source_builder = SourceBuilder::new();
+        let source_builder = App::new();
 
         let dev_bundle = generate_axum_source(&source_builder, Mode::Dev);
         assert!(dev_bundle.contains("const MODE: Mode = Mode::Dev;"));
@@ -353,10 +225,25 @@ mod tests {
     }
 
     #[test]
-    fn should_correctly_print_the_mode_as_str() {
-        let dev = Mode::Dev.as_str();
-        let prod = Mode::Prod.as_str();
-        assert_eq!(dev, "Mode::Dev");
-        assert_eq!(prod, "Mode::Prod");
+    fn should_not_load_the_axum_get_function() {
+        let source_builder = App::new();
+
+        let dev_bundle = generate_axum_source(&source_builder, Mode::Dev);
+        assert!(!dev_bundle.contains("use tuono_lib::axum::routing::get;"));
+    }
+
+    #[test]
+    fn should_load_the_axum_get_function() {
+        let mut source_builder = App::new();
+
+        let mut route = Route::new(String::from("index.tsx"));
+        route.update_axum_info();
+
+        source_builder
+            .route_map
+            .insert(String::from("index.rs"), route);
+
+        let dev_bundle = generate_axum_source(&source_builder, Mode::Dev);
+        assert!(dev_bundle.contains("use tuono_lib::axum::routing::get;"));
     }
 }

crates/tuono/src/watch.rs

@@ -1,3 +1,4 @@
+use std::path::Path;
 use std::sync::Arc;
 use watchexec_supervisor::command::{Command, Program};
 
@@ -6,12 +7,29 @@ use watchexec::Watchexec;
 use watchexec_signals::Signal;
 use watchexec_supervisor::job::{start_job, Job};
 
-use crate::source_builder::{bundle_axum_source, Mode};
+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(),
@@ -19,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(),
@@ -30,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(),
@@ -43,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;
@@ -62,22 +105,23 @@ pub async fn watch() -> Result<()> {
 
         for event in action.events.iter() {
             for path in event.paths() {
-                if path.0.to_string_lossy().ends_with(".rs") {
+                let file_path = path.0.to_string_lossy();
+                if file_path.ends_with(".rs") {
                     should_reload_rust_server = true
                 }
 
-                // Either tsx and jsx
-                if path.0.to_string_lossy().ends_with("sx") {
+                // Either tsx, jsx and mdx
+                if file_path.ends_with("sx") || file_path.ends_with("mdx") {
                     should_reload_ssr_bundle = true
                 }
             }
         }
 
         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.4.5"
+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,26 +15,34 @@ 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"
 serde_json = "1.0"
+serde_urlencoded = "0.7.1"
 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.4.5"}
+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

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

crates/tuono_lib/src/payload.rs

@@ -1,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: &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;
                         }
@@ -135,7 +166,7 @@ mod tests {
 
     use crate::manifest::BundleInfo;
 
-    fn prepare_payload(uri: Option<&str>, mode: Mode) -> Payload<'static> {
+    fn prepare_payload<'a>(uri: Option<&'a str>, mode: Mode) -> Payload<'a> {
         let mut manifest_mock = HashMap::new();
         manifest_mock.insert(
             "client-main".to_string(),
@@ -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 {
@@ -185,18 +224,21 @@ mod tests {
             },
         );
         MANIFEST.get_or_init(|| manifest_mock);
-        let location = Location::from(
-            uri.unwrap_or("http://localhost:3000/")
-                .parse::<Uri>()
-                .unwrap(),
-        );
+
+        let uri = uri
+            .unwrap_or("http://localhost:3000/")
+            .parse::<Uri>()
+            .unwrap();
+
+        let location = Location::from(uri);
 
         Payload {
-            router: location,
-            props: &None::<Option<()>>,
+            location,
+            data: &None::<Option<()>>,
             mode,
             js_bundles: None,
             css_bundles: None,
+            dev_server_config: None,
         }
     }
 
@@ -272,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

@@ -8,9 +8,9 @@ use axum::http::{HeaderMap, Uri};
 pub struct Location {
     href: String,
     pathname: String,
-    search: HashMap<String, String>,
+    #[serde(rename(serialize = "searchStr"))]
     search_str: String,
-    hash: String,
+    search: HashMap<String, String>,
 }
 
 impl Location {
@@ -21,20 +21,20 @@ impl Location {
 
 impl From<Uri> for Location {
     fn from(uri: Uri) -> Self {
+        let query = uri.query().unwrap_or("");
         Location {
+            // TODO: build correct href
             href: uri.to_string(),
             pathname: uri.path().to_string(),
-            // TODO: handler search map
-            search: HashMap::new(),
-            search_str: uri.query().unwrap_or("").to_string(),
-            hash: "".to_string(),
+            search_str: query.to_string(),
+            search: serde_urlencoded::from_str(query).unwrap_or(HashMap::new()),
         }
     }
 }
 
 #[derive(Debug, Clone)]
 pub struct Request {
-    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.4.5"
+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,614 +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)
-* [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.
-
-## 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

@@ -0,0 +1,13 @@
+[package]
+name = "tuono-app"
+version = "0.0.1"
+edition = "2021"
+
+[[bin]]
+name = "tuono"
+path = ".tuono/main.rs"
+
+[dependencies]
+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,16 +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.
-
-

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"
+  }
+}