@ngxtm/devkit 3.4.0 → 3.4.1

package/rules/rust/rocket/SKILL.md

@@ -0,0 +1,182 @@
+---
+name: Rocket Framework
+description: Type-safe, async Rust web framework with intuitive API.
+metadata:
+  labels: [rust, rocket, web, framework]
+  triggers:
+    files: ['**/main.rs', 'Rocket.toml']
+    keywords: [rocket, get, post, launch, routes]
+---
+
+# Rocket Framework Standards
+
+## Application Setup
+
+```rust
+#[macro_use] extern crate rocket;
+
+#[launch]
+fn rocket() -> _ {
+    rocket::build()
+        .mount("/", routes![index, users])
+        .mount("/api", routes![api_routes])
+        .attach(DbConn::fairing())
+        .manage(AppState::new())
+}
+
+#[get("/")]
+fn index() -> &'static str {
+    "Hello, world!"
+}
+```
+
+## Route Handlers
+
+```rust
+// Path parameters
+#[get("/users/<id>")]
+fn get_user(id: i64) -> Json<User> {
+    Json(find_user(id))
+}
+
+// Optional parameters
+#[get("/users?<page>&<limit>")]
+fn list_users(page: Option<u32>, limit: Option<u32>) -> Json<Vec<User>> {
+    let page = page.unwrap_or(1);
+    let limit = limit.unwrap_or(10);
+    Json(fetch_users(page, limit))
+}
+
+// Multiple segments
+#[get("/files/<path..>")]
+fn get_file(path: PathBuf) -> Option<NamedFile> {
+    NamedFile::open(Path::new("static/").join(path)).ok()
+}
+```
+
+## Request Guards
+
+```rust
+use rocket::request::{FromRequest, Outcome};
+
+struct AuthUser {
+    id: i64,
+    role: String,
+}
+
+#[rocket::async_trait]
+impl<'r> FromRequest<'r> for AuthUser {
+    type Error = AuthError;
+
+    async fn from_request(req: &'r Request<'_>) -> Outcome<Self, Self::Error> {
+        match req.headers().get_one("Authorization") {
+            Some(token) => match validate_token(token).await {
+                Ok(user) => Outcome::Success(user),
+                Err(e) => Outcome::Error((Status::Unauthorized, e)),
+            },
+            None => Outcome::Forward(Status::Unauthorized),
+        }
+    }
+}
+
+#[get("/protected")]
+fn protected(user: AuthUser) -> String {
+    format!("Hello, {}", user.id)
+}
+```
+
+## JSON Handling
+
+```rust
+use rocket::serde::json::Json;
+
+#[derive(Serialize, Deserialize)]
+struct CreateUser {
+    name: String,
+    email: String,
+}
+
+#[post("/users", data = "<user>")]
+fn create_user(user: Json<CreateUser>) -> Result<Json<User>, Status> {
+    let user = user.into_inner();
+    match insert_user(&user) {
+        Ok(created) => Ok(Json(created)),
+        Err(_) => Err(Status::InternalServerError),
+    }
+}
+```
+
+## State Management
+
+```rust
+struct AppState {
+    config: Config,
+    cache: Cache,
+}
+
+#[launch]
+fn rocket() -> _ {
+    rocket::build()
+        .manage(AppState::new())
+        .mount("/", routes![handler])
+}
+
+#[get("/config")]
+fn handler(state: &State<AppState>) -> String {
+    state.config.name.clone()
+}
+```
+
+## Fairings (Middleware)
+
+```rust
+use rocket::fairing::{Fairing, Info, Kind};
+
+struct RequestLogger;
+
+#[rocket::async_trait]
+impl Fairing for RequestLogger {
+    fn info(&self) -> Info {
+        Info {
+            name: "Request Logger",
+            kind: Kind::Request | Kind::Response,
+        }
+    }
+
+    async fn on_request(&self, req: &mut Request<'_>, _: &mut Data<'_>) {
+        println!("Request: {} {}", req.method(), req.uri());
+    }
+
+    async fn on_response<'r>(&self, _: &'r Request<'_>, res: &mut Response<'r>) {
+        println!("Response: {}", res.status());
+    }
+}
+```
+
+## Error Handling
+
+```rust
+#[catch(404)]
+fn not_found() -> Json<ErrorResponse> {
+    Json(ErrorResponse { error: "Not found".into() })
+}
+
+#[catch(500)]
+fn internal_error() -> Json<ErrorResponse> {
+    Json(ErrorResponse { error: "Internal server error".into() })
+}
+
+#[launch]
+fn rocket() -> _ {
+    rocket::build()
+        .register("/", catchers![not_found, internal_error])
+}
+```
+
+## Best Practices
+
+1. **Guards**: Use request guards for auth, validation
+2. **Managed state**: Prefer `&State<T>` over global state
+3. **Fairings**: Use for cross-cutting concerns
+4. **Configuration**: Use `Rocket.toml` for environment-specific config
+5. **Testing**: Use `rocket::local::blocking::Client` for tests

package/rules/rust/rocket/references/REFERENCE.md

@@ -0,0 +1,13 @@
+# Rocket Framework References
+
+## References
+
+- [**Handler Patterns**](handler-patterns.md) - Routes, guards, responses
+
+## Quick Checks
+
+- [ ] Use #[rocket::main] for entry point
+- [ ] Request guards for validation
+- [ ] Responder trait for custom responses
+- [ ] Fairings for middleware
+- [ ] Managed state for shared data

package/rules/rust/rocket/references/handler-patterns.md

@@ -0,0 +1,209 @@
+# Rocket Handler Patterns
+
+## Basic Routes
+
+```rust
+#[macro_use] extern crate rocket;
+
+use rocket::serde::json::Json;
+use serde::{Deserialize, Serialize};
+
+#[get("/")]
+fn index() -> &'static str {
+    "Hello, world!"
+}
+
+#[get("/users/<id>")]
+fn get_user(id: i64) -> Json<User> {
+    Json(User { id, name: "John".into() })
+}
+
+#[post("/users", data = "<user>")]
+fn create_user(user: Json<CreateUser>) -> Json<User> {
+    Json(User {
+        id: 1,
+        name: user.name.clone(),
+    })
+}
+
+#[launch]
+fn rocket() -> _ {
+    rocket::build()
+        .mount("/", routes![index, get_user, create_user])
+}
+
+#[derive(Serialize)]
+struct User {
+    id: i64,
+    name: String,
+}
+
+#[derive(Deserialize)]
+struct CreateUser {
+    name: String,
+}
+```
+
+## Request Guards
+
+```rust
+use rocket::request::{self, FromRequest, Request};
+use rocket::http::Status;
+
+struct ApiKey<'r>(&'r str);
+
+#[rocket::async_trait]
+impl<'r> FromRequest<'r> for ApiKey<'r> {
+    type Error = ();
+
+    async fn from_request(req: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
+        match req.headers().get_one("X-Api-Key") {
+            Some(key) if is_valid(key) => request::Outcome::Success(ApiKey(key)),
+            Some(_) => request::Outcome::Error((Status::Unauthorized, ())),
+            None => request::Outcome::Forward(Status::Unauthorized),
+        }
+    }
+}
+
+#[get("/protected")]
+fn protected(key: ApiKey<'_>) -> &'static str {
+    "Secret data"
+}
+
+// Optional guard
+#[get("/maybe-auth")]
+fn maybe_auth(key: Option<ApiKey<'_>>) -> &'static str {
+    match key {
+        Some(_) => "Authenticated",
+        None => "Anonymous",
+    }
+}
+```
+
+## Managed State
+
+```rust
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+struct HitCount(AtomicUsize);
+
+#[get("/count")]
+fn count(hit_count: &State<HitCount>) -> String {
+    let count = hit_count.0.fetch_add(1, Ordering::Relaxed);
+    format!("Hits: {}", count)
+}
+
+#[launch]
+fn rocket() -> _ {
+    rocket::build()
+        .manage(HitCount(AtomicUsize::new(0)))
+        .mount("/", routes![count])
+}
+```
+
+## Error Handling
+
+```rust
+use rocket::response::status;
+use rocket::http::Status;
+
+#[derive(Responder)]
+pub enum ApiResponse<T> {
+    #[response(status = 200)]
+    Ok(Json<T>),
+    #[response(status = 404)]
+    NotFound(Json<ErrorMessage>),
+    #[response(status = 500)]
+    InternalError(Json<ErrorMessage>),
+}
+
+#[derive(Serialize)]
+pub struct ErrorMessage {
+    message: String,
+}
+
+#[get("/users/<id>")]
+async fn get_user(id: i64, db: &State<Database>) -> ApiResponse<User> {
+    match db.find_user(id).await {
+        Ok(Some(user)) => ApiResponse::Ok(Json(user)),
+        Ok(None) => ApiResponse::NotFound(Json(ErrorMessage {
+            message: "User not found".into(),
+        })),
+        Err(_) => ApiResponse::InternalError(Json(ErrorMessage {
+            message: "Database error".into(),
+        })),
+    }
+}
+
+// Catchers for default error pages
+#[catch(404)]
+fn not_found() -> Json<ErrorMessage> {
+    Json(ErrorMessage { message: "Not found".into() })
+}
+
+#[catch(500)]
+fn internal_error() -> Json<ErrorMessage> {
+    Json(ErrorMessage { message: "Internal error".into() })
+}
+
+#[launch]
+fn rocket() -> _ {
+    rocket::build()
+        .register("/", catchers![not_found, internal_error])
+}
+```
+
+## Fairings (Middleware)
+
+```rust
+use rocket::fairing::{Fairing, Info, Kind};
+use rocket::{Request, Response, Data};
+
+pub struct Timer;
+
+#[rocket::async_trait]
+impl Fairing for Timer {
+    fn info(&self) -> Info {
+        Info {
+            name: "Request Timer",
+            kind: Kind::Request | Kind::Response,
+        }
+    }
+
+    async fn on_request(&self, request: &mut Request<'_>, _: &mut Data<'_>) {
+        request.local_cache(|| std::time::Instant::now());
+    }
+
+    async fn on_response<'r>(&self, request: &'r Request<'_>, response: &mut Response<'r>) {
+        let start = request.local_cache(|| std::time::Instant::now());
+        let duration = start.elapsed();
+        response.set_raw_header("X-Response-Time", format!("{}ms", duration.as_millis()));
+    }
+}
+
+#[launch]
+fn rocket() -> _ {
+    rocket::build()
+        .attach(Timer)
+}
+```
+
+## Forms and Validation
+
+```rust
+use rocket::form::{Form, FromForm};
+
+#[derive(FromForm)]
+struct LoginForm<'r> {
+    #[field(validate = len(3..=20))]
+    username: &'r str,
+    #[field(validate = len(8..))]
+    password: &'r str,
+}
+
+#[post("/login", data = "<form>")]
+fn login(form: Form<LoginForm<'_>>) -> &'static str {
+    // Process login
+    "Logged in"
+}
+```

package/rules/rust/sea-orm/SKILL.md

@@ -0,0 +1,230 @@
+---
+name: SeaORM
+description: Async ORM for Rust with compile-time checked queries.
+metadata:
+  labels: [rust, sea-orm, orm, database, async]
+  triggers:
+    files: ['**/entity/*.rs', '**/migration/*.rs']
+    keywords: [sea_orm, Entity, ActiveModel, DbConn, Select]
+---
+
+# SeaORM Standards
+
+## Entity Definition
+
+```rust
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "users")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub name: String,
+    #[sea_orm(unique)]
+    pub email: String,
+    pub created_at: DateTimeUtc,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_many = "super::post::Entity")]
+    Posts,
+}
+
+impl Related<super::post::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Posts.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+```
+
+## Connection
+
+```rust
+use sea_orm::{Database, DbConn, ConnectOptions};
+
+async fn connect() -> Result<DbConn, DbErr> {
+    let mut opt = ConnectOptions::new("postgres://user:pass@localhost/db");
+    opt.max_connections(100)
+       .min_connections(5)
+       .sqlx_logging(true);
+
+    Database::connect(opt).await
+}
+```
+
+## CRUD Operations
+
+```rust
+use sea_orm::{ActiveModelTrait, EntityTrait, Set};
+
+// Create
+async fn create_user(db: &DbConn, name: String, email: String) -> Result<user::Model, DbErr> {
+    let user = user::ActiveModel {
+        name: Set(name),
+        email: Set(email),
+        created_at: Set(Utc::now()),
+        ..Default::default()
+    };
+    user.insert(db).await
+}
+
+// Read
+async fn find_user(db: &DbConn, id: i32) -> Result<Option<user::Model>, DbErr> {
+    User::find_by_id(id).one(db).await
+}
+
+async fn find_all(db: &DbConn) -> Result<Vec<user::Model>, DbErr> {
+    User::find().all(db).await
+}
+
+// Update
+async fn update_user(db: &DbConn, id: i32, name: String) -> Result<user::Model, DbErr> {
+    let user: user::ActiveModel = User::find_by_id(id)
+        .one(db)
+        .await?
+        .ok_or(DbErr::RecordNotFound("User not found".into()))?
+        .into();
+
+    user::ActiveModel {
+        name: Set(name),
+        ..user
+    }.update(db).await
+}
+
+// Delete
+async fn delete_user(db: &DbConn, id: i32) -> Result<DeleteResult, DbErr> {
+    User::delete_by_id(id).exec(db).await
+}
+```
+
+## Queries
+
+```rust
+use sea_orm::{Condition, QueryFilter, QueryOrder, QuerySelect};
+
+// Filter
+let users = User::find()
+    .filter(user::Column::Email.contains("@example.com"))
+    .filter(user::Column::CreatedAt.gt(cutoff_date))
+    .all(db)
+    .await?;
+
+// Complex conditions
+let users = User::find()
+    .filter(
+        Condition::any()
+            .add(user::Column::Role.eq("admin"))
+            .add(user::Column::Role.eq("moderator"))
+    )
+    .all(db)
+    .await?;
+
+// Order and limit
+let users = User::find()
+    .order_by_desc(user::Column::CreatedAt)
+    .limit(10)
+    .offset(20)
+    .all(db)
+    .await?;
+
+// Select specific columns
+let names: Vec<String> = User::find()
+    .select_only()
+    .column(user::Column::Name)
+    .into_tuple()
+    .all(db)
+    .await?;
+```
+
+## Relations
+
+```rust
+// Define relation in entity
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::user::Entity",
+        from = "Column::AuthorId",
+        to = "super::user::Column::Id"
+    )]
+    Author,
+}
+
+// Eager loading
+let posts_with_authors = Post::find()
+    .find_also_related(User)
+    .all(db)
+    .await?;
+
+// Lazy loading
+let user = User::find_by_id(1).one(db).await?;
+let posts = user.find_related(Post).all(db).await?;
+```
+
+## Transactions
+
+```rust
+use sea_orm::TransactionTrait;
+
+async fn transfer(db: &DbConn, from: i32, to: i32, amount: i32) -> Result<(), DbErr> {
+    db.transaction::<_, (), DbErr>(|txn| {
+        Box::pin(async move {
+            // Debit from source
+            let from_account = Account::find_by_id(from).one(txn).await?.unwrap();
+            account::ActiveModel {
+                balance: Set(from_account.balance - amount),
+                ..from_account.into()
+            }.update(txn).await?;
+
+            // Credit to destination
+            let to_account = Account::find_by_id(to).one(txn).await?.unwrap();
+            account::ActiveModel {
+                balance: Set(to_account.balance + amount),
+                ..to_account.into()
+            }.update(txn).await?;
+
+            Ok(())
+        })
+    }).await
+}
+```
+
+## Migrations
+
+```rust
+// migration/src/m20220101_000001_create_users.rs
+use sea_orm_migration::prelude::*;
+
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager.create_table(
+            Table::create()
+                .table(Users::Table)
+                .col(ColumnDef::new(Users::Id).integer().auto_increment().primary_key())
+                .col(ColumnDef::new(Users::Name).string().not_null())
+                .col(ColumnDef::new(Users::Email).string().unique_key().not_null())
+                .to_owned()
+        ).await
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager.drop_table(Table::drop().table(Users::Table).to_owned()).await
+    }
+}
+```
+
+## Best Practices
+
+1. **ActiveModel**: Use `Set()` for values to update
+2. **Transactions**: Wrap related operations
+3. **Migrations**: Use sea-orm-cli for generation
+4. **Relations**: Define both sides of relationships
+5. **Logging**: Enable sqlx_logging for debugging

package/rules/rust/sea-orm/references/REFERENCE.md

@@ -0,0 +1,13 @@
+# Sea ORM References
+
+## References
+
+- [**Entity Patterns**](entity-patterns.md) - Models, queries, relations
+
+## Quick Checks
+
+- [ ] Derive DeriveEntityModel for entities
+- [ ] Use ActiveModel for inserts/updates
+- [ ] Define relations with Related trait
+- [ ] Async/await native support
+- [ ] Compatible with SQLx runtime