Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

rust-backend

/rust-backend

Podaje wytyczne kodowania w Rust dla backendu Windmill, obowiązujące przy każdym pisaniu i zmianie kodu Rust w katalogu backend.

Repozytorium
windmill ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
25.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 25.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Podaje wytyczne kodowania w Rust dla backendu Windmill, obowiązujące przy każdym pisaniu i zmianie kodu Rust w katalogu backend.

Oryginalny opis (EN)

Rust coding guidelines for the Windmill backend. MUST use when writing or modifying Rust code in the backend directory.

Jak działa

  1. Error Handling
  2. SQLx Patterns
  3. JSON Handling
  4. Serde Optimizations
  5. Async & Concurrency
  6. Module Structure & Visibility
  7. Code Navigation
  8. Feature Telemetry
  9. Axum Handlers
Sekcje z nagłówków SKILL.md, w oryginale · 111 linii, 401 słów
Podgląd SKILL.md
---
name: rust-backend
description: Rust coding guidelines for the Windmill backend. MUST use when writing or modifying Rust code in the backend directory.
---

# Windmill Rust Patterns

Apply these Windmill-specific patterns when writing Rust code in `backend/`.

## Error Handling

Use `Error` from `windmill_common::error`. Return `Result<T, Error>` or `JsonResult<T>`:

```rust
use windmill_common::error::{Error, Result};

pub async fn get_job(db: &DB, id: Uuid) -> Result<Job> {
    sqlx::query_as!(Job, "SELECT id, workspace_id FROM v2_job WHERE id = $1", id)
        .fetch_optional(db)
        .await?
        .ok_or_else(|| Error::NotFound("job not found".to_string()))?;
}
```

Never panic in library code. Reserve `.unwrap()` for compile-time guarantees.

## SQLx Patterns

**Never use `SELECT *`** — always list columns explicitly. Critical for backwards compatibility when workers lag behind API version:

```rust
// Correct
sqlx::query_as!(Job, "SELECT id, workspace_id, path FROM v2_job WHERE id = $1", id)

// Wrong — breaks when columns are added
sqlx::query_as!(Job, "SELECT * FROM v2_job WHERE id = $1", id)
```

Use batch operations to avoid N+1:

```rust
// Preferred — single query with IN clause
sqlx::query!("SELECT ... WHERE id = ANY($1)", &ids[..]).fetch_all(db).await?
```

Use transactions for multi-step operations. Parameterize all queries.

## JSON Handling

Prefer `Box<serde_json::value::RawValue>` over `serde_json::Value` when storing/passing JSON without inspection:

```rust
pub struct Job {
    pub args: Option<Box<serde_json::value::RawValue>>,
}
```

Only use `serde_json::Value` when you need to inspect or modify the JSON.

## Serde Optimizations

```rust
#[derive(Serialize, Deserialize)]
pub struct Job {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parent_job: Option<Uuid>,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub tags: Vec<String>,
    #[serde(default)]
    pub priority: i32,
}
```

## Async & Concurrency

Never block the async runtime. Use `spawn_blocking` for CPU-intensive work:

```rust
let result = tokio::task::spawn_blocking(move || expensive_computation(&data)).await?;
```

**Mutex selection**: Prefer `std::sync::Mutex` (or `parking_lot::Mutex`) for data protection. Only use `tokio::sync::Mutex` when holding locks across `.await` points.

Use `tokio::sync::mpsc` (bounded) for channels. Avoid `std::thread::sleep` in async contexts.

## Module Structure & Visibility

- Use `pub(crate)` instead of `pub` when possible
- Place new code in the appropriate crate based on functionality
- API endpoints go in `windmill-api/src/` organized by domain
- Shared functionality goes in `windmill-common/src/`

## Code Navigation

Always use rust-analyzer LSP for go-to-definition, find-references, and type info. Do not guess at module paths.

## Feature Telemetry

`FEATURE_USAGE_KINDS` in `windmill-api-workspaces/src/workspaces.rs` is an allowlist: a
`(feature, kind)` pair missing from it is dropped by `valid_feature_usage_event` with a bare
`continue` — no error, and the route still returns 204. Adding a counter on the frontend without
registering it here records nothing. See `docs/feature-telemetry.md`.

## Axum Handlers

Destructure extractors directly in function signatures:

```rust
async fn process_job(
    Extension(db): Extension<DB>,
    Path((workspace, job_id)): Path<(String, Uuid)>,
    Query(pagination): Query<Pagination>,
) -> Result<Json<Job>> { ... }
```

Wersje

RepozytoriumWynikLicencja
Ta strona · windmill-labs/windmill100Apache-2.0
Funnyhust/POC_Kaenx_Creator100GPL-3.0
zjunlp/skills100MIT

Migawka bazy z 13.11.2026 · wersja paczki eb7b5141828c (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100svelte-frontend
    Podaje wytyczne kodowania w Svelte dla frontendu Windmill, obowiązkowe przy pisaniu i zmianach kodu w katalogu frontend.
  • 86rust-tests-guidelines
    Podaje wytyczne pisania testów w Rust, gdy trzeba napisać testy dla kodu w tym języku.
  • 100rust
    Podpowiada dobre praktyki Rust przy pisaniu i przeglądzie kodu: struktura, wzorce, wydajność i obsługa błędów.
  • 95native-trigger
    Prowadzi dodawanie natywnych usług wyzwalaczy do Windmill, przy implementowaniu lub zmianie integracji natywnych wyzwalaczy w backendzie i frontendzie.
  • 100rust-coding-style
    Opisuje styl kodowania Rust w HASH: dobór typów, importy, argumenty funkcji i nazewnictwo, przy pisaniu i przeglądzie kodu.
  • 100rust
    Podpowiada konwencje kodowania i dobre praktyki Rust przy każdej pracy z plikami .rs.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.