@ngxtm/devkit 3.4.0 → 3.4.1

package/rules/rust/actix-web/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: Actix-web Framework
+description: High-performance Rust web framework with actor model foundation.
+metadata:
+  labels: [rust, actix-web, web, framework]
+  triggers:
+    files: ['**/main.rs', '**/handlers/*.rs']
+    keywords: [actix_web, HttpServer, web, App]
+---
+
+# Actix-web Standards
+
+## Handler Functions
+
+```rust
+use actix_web::{web, HttpResponse, Result};
+
+// Path parameters
+async fn get_user(path: web::Path<u64>) -> Result<HttpResponse> {
+    let user_id = path.into_inner();
+    Ok(HttpResponse::Ok().json(user))
+}
+
+// Query parameters
+#[derive(Deserialize)]
+struct Pagination {
+    page: Option<u32>,
+    limit: Option<u32>,
+}
+
+async fn list_users(query: web::Query<Pagination>) -> Result<HttpResponse> {
+    let page = query.page.unwrap_or(1);
+    Ok(HttpResponse::Ok().json(users))
+}
+
+// JSON body
+async fn create_user(body: web::Json<CreateUser>) -> Result<HttpResponse> {
+    let user = body.into_inner();
+    Ok(HttpResponse::Created().json(created))
+}
+```
+
+## Extractors
+
+| Extractor | Purpose |
+|-----------|---------|
+| `web::Path<T>` | URL path parameters |
+| `web::Query<T>` | Query string |
+| `web::Json<T>` | JSON request body |
+| `web::Form<T>` | Form data |
+| `web::Data<T>` | Application state |
+| `HttpRequest` | Full request access |
+
+**Custom Extractors**:
+```rust
+impl FromRequest for AuthUser {
+    type Error = Error;
+    type Future = Ready<Result<Self, Self::Error>>;
+
+    fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
+        // Extract and validate auth header
+    }
+}
+```
+
+## State Management
+
+```rust
+struct AppState {
+    db: PgPool,
+    cache: RedisPool,
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    let state = web::Data::new(AppState {
+        db: create_pool().await,
+        cache: create_cache().await,
+    });
+
+    HttpServer::new(move || {
+        App::new()
+            .app_data(state.clone())
+            .service(handlers)
+    })
+    .bind("127.0.0.1:8080")?
+    .run()
+    .await
+}
+
+// Access in handlers
+async fn handler(state: web::Data<AppState>) -> Result<HttpResponse> {
+    let conn = state.db.acquire().await?;
+    Ok(HttpResponse::Ok().finish())
+}
+```
+
+## Middleware
+
+```rust
+use actix_web::middleware::{Logger, Compress, NormalizePath};
+
+App::new()
+    .wrap(Logger::default())
+    .wrap(Compress::default())
+    .wrap(NormalizePath::trim())
+    .wrap(custom_middleware)
+
+// Custom middleware
+async fn auth_middleware(
+    req: ServiceRequest,
+    srv: &Service,
+) -> Result<ServiceResponse, Error> {
+    // Validate token
+    srv.call(req).await
+}
+```
+
+## Error Handling
+
+```rust
+use actix_web::{error, HttpResponse};
+
+#[derive(Debug, thiserror::Error)]
+enum ApiError {
+    #[error("Not found")]
+    NotFound,
+    #[error("Database error")]
+    Database(#[from] sqlx::Error),
+}
+
+impl error::ResponseError for ApiError {
+    fn error_response(&self) -> HttpResponse {
+        match self {
+            ApiError::NotFound => HttpResponse::NotFound().json({"error": "Not found"}),
+            ApiError::Database(_) => HttpResponse::InternalServerError().finish(),
+        }
+    }
+}
+```
+
+## Routing
+
+```rust
+App::new()
+    .route("/", web::get().to(index))
+    .service(
+        web::scope("/api/v1")
+            .route("/users", web::get().to(list_users))
+            .route("/users/{id}", web::get().to(get_user))
+            .route("/users", web::post().to(create_user))
+    )
+```
+
+## Best Practices
+
+1. **Concurrency**: Use `.workers(N)` to control thread pool size
+2. **Timeouts**: Configure `keep_alive` and client timeouts
+3. **Graceful Shutdown**: Handle SIGTERM properly
+4. **Testing**: Use `actix_web::test` for integration tests

package/rules/rust/actix-web/references/REFERENCE.md

@@ -0,0 +1,13 @@
+# Actix Web References
+
+## References
+
+- [**Handler Patterns**](handler-patterns.md) - Extractors, responses, middleware
+
+## Quick Checks
+
+- [ ] Use extractors for request data
+- [ ] Implement Responder for custom responses
+- [ ] Data for shared application state
+- [ ] Configure workers appropriately
+- [ ] Error handling with actix_web::Error

package/rules/rust/actix-web/references/handler-patterns.md

@@ -0,0 +1,198 @@
+# Actix Web Handler Patterns
+
+## Basic Handlers
+
+```rust
+use actix_web::{web, App, HttpServer, HttpResponse, Responder};
+
+async fn hello() -> impl Responder {
+    HttpResponse::Ok().body("Hello world!")
+}
+
+async fn echo(req_body: String) -> impl Responder {
+    HttpResponse::Ok().body(req_body)
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    HttpServer::new(|| {
+        App::new()
+            .route("/", web::get().to(hello))
+            .route("/echo", web::post().to(echo))
+    })
+    .bind(("127.0.0.1", 8080))?
+    .run()
+    .await
+}
+```
+
+## Extractors
+
+```rust
+use actix_web::{web, HttpResponse};
+use serde::Deserialize;
+
+// Path parameters
+async fn get_user(path: web::Path<(u64,)>) -> HttpResponse {
+    let user_id = path.into_inner().0;
+    HttpResponse::Ok().json(format!("User {}", user_id))
+}
+
+// Named path parameters
+#[derive(Deserialize)]
+struct UserPath {
+    id: u64,
+}
+
+async fn get_user_named(path: web::Path<UserPath>) -> HttpResponse {
+    HttpResponse::Ok().json(format!("User {}", path.id))
+}
+
+// Query parameters
+#[derive(Deserialize)]
+struct ListQuery {
+    page: Option<u32>,
+    limit: Option<u32>,
+}
+
+async fn list_users(query: web::Query<ListQuery>) -> HttpResponse {
+    let page = query.page.unwrap_or(1);
+    let limit = query.limit.unwrap_or(10);
+    HttpResponse::Ok().json(format!("Page {} limit {}", page, limit))
+}
+
+// JSON body
+#[derive(Deserialize)]
+struct CreateUser {
+    name: String,
+    email: String,
+}
+
+async fn create_user(body: web::Json<CreateUser>) -> HttpResponse {
+    HttpResponse::Created().json(format!("Created {}", body.name))
+}
+```
+
+## Application State
+
+```rust
+use std::sync::Mutex;
+
+struct AppState {
+    counter: Mutex<i32>,
+    db: PgPool,
+}
+
+async fn increment(data: web::Data<AppState>) -> HttpResponse {
+    let mut counter = data.counter.lock().unwrap();
+    *counter += 1;
+    HttpResponse::Ok().json(*counter)
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    let pool = create_pool().await;
+    let state = web::Data::new(AppState {
+        counter: Mutex::new(0),
+        db: pool,
+    });
+
+    HttpServer::new(move || {
+        App::new()
+            .app_data(state.clone())
+            .route("/count", web::get().to(increment))
+    })
+    .bind("127.0.0.1:8080")?
+    .run()
+    .await
+}
+```
+
+## Error Handling
+
+```rust
+use actix_web::{error, HttpResponse};
+use derive_more::{Display, Error};
+
+#[derive(Debug, Display, Error)]
+enum AppError {
+    #[display(fmt = "Not found")]
+    NotFound,
+    #[display(fmt = "Bad request: {}", _0)]
+    BadRequest(String),
+    #[display(fmt = "Internal error")]
+    Internal,
+}
+
+impl error::ResponseError for AppError {
+    fn error_response(&self) -> HttpResponse {
+        match self {
+            AppError::NotFound => HttpResponse::NotFound().json("Not found"),
+            AppError::BadRequest(msg) => HttpResponse::BadRequest().json(msg),
+            AppError::Internal => HttpResponse::InternalServerError().json("Error"),
+        }
+    }
+}
+
+async fn get_user(path: web::Path<u64>) -> Result<HttpResponse, AppError> {
+    let user = find_user(path.into_inner())
+        .await
+        .ok_or(AppError::NotFound)?;
+    Ok(HttpResponse::Ok().json(user))
+}
+```
+
+## Middleware
+
+```rust
+use actix_web::middleware::{Logger, Compress};
+use actix_cors::Cors;
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    HttpServer::new(|| {
+        let cors = Cors::default()
+            .allowed_origin("https://example.com")
+            .allowed_methods(vec!["GET", "POST"])
+            .max_age(3600);
+
+        App::new()
+            .wrap(Logger::default())
+            .wrap(Compress::default())
+            .wrap(cors)
+            .service(web::resource("/").to(index))
+    })
+    .bind("127.0.0.1:8080")?
+    .run()
+    .await
+}
+```
+
+## Route Configuration
+
+```rust
+fn config(cfg: &mut web::ServiceConfig) {
+    cfg.service(
+        web::resource("/users")
+            .route(web::get().to(list_users))
+            .route(web::post().to(create_user))
+    )
+    .service(
+        web::resource("/users/{id}")
+            .route(web::get().to(get_user))
+            .route(web::put().to(update_user))
+            .route(web::delete().to(delete_user))
+    );
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    HttpServer::new(|| {
+        App::new()
+            .configure(config)
+    })
+    .bind("127.0.0.1:8080")?
+    .run()
+    .await
+}
+```

package/rules/rust/async-graphql/SKILL.md

@@ -0,0 +1,228 @@
+---
+name: async-graphql
+description: High-performance GraphQL server library for Rust.
+metadata:
+  labels: [rust, graphql, async-graphql, api]
+  triggers:
+    files: ['**/schema.rs', '**/graphql.rs']
+    keywords: [async_graphql, Object, Query, Mutation, Subscription, Schema]
+---
+
+# async-graphql Standards
+
+## Schema Setup
+
+```rust
+use async_graphql::{Schema, EmptySubscription};
+
+type AppSchema = Schema<QueryRoot, MutationRoot, EmptySubscription>;
+
+fn create_schema(db: Database) -> AppSchema {
+    Schema::build(QueryRoot, MutationRoot, EmptySubscription)
+        .data(db)
+        .finish()
+}
+```
+
+## Query
+
+```rust
+use async_graphql::{Object, Context, Result};
+
+struct QueryRoot;
+
+#[Object]
+impl QueryRoot {
+    async fn user(&self, ctx: &Context<'_>, id: i32) -> Result<Option<User>> {
+        let db = ctx.data::<Database>()?;
+        Ok(db.find_user(id).await?)
+    }
+
+    async fn users(
+        &self,
+        ctx: &Context<'_>,
+        #[graphql(default = 10)] limit: i32,
+        #[graphql(default = 0)] offset: i32,
+    ) -> Result<Vec<User>> {
+        let db = ctx.data::<Database>()?;
+        Ok(db.list_users(limit, offset).await?)
+    }
+}
+```
+
+## Types
+
+```rust
+use async_graphql::{Object, SimpleObject, InputObject, Enum};
+
+// Simple object (auto-implement resolvers)
+#[derive(SimpleObject)]
+struct User {
+    id: i32,
+    name: String,
+    email: String,
+    #[graphql(skip)]  // Don't expose
+    password_hash: String,
+}
+
+// Complex object (custom resolvers)
+#[Object]
+impl User {
+    async fn posts(&self, ctx: &Context<'_>) -> Result<Vec<Post>> {
+        let db = ctx.data::<Database>()?;
+        Ok(db.posts_by_user(self.id).await?)
+    }
+}
+
+// Input type
+#[derive(InputObject)]
+struct CreateUserInput {
+    name: String,
+    email: String,
+    password: String,
+}
+
+// Enum
+#[derive(Enum, Copy, Clone, Eq, PartialEq)]
+enum Role {
+    Admin,
+    User,
+    Guest,
+}
+```
+
+## Mutation
+
+```rust
+struct MutationRoot;
+
+#[Object]
+impl MutationRoot {
+    async fn create_user(
+        &self,
+        ctx: &Context<'_>,
+        input: CreateUserInput,
+    ) -> Result<User> {
+        let db = ctx.data::<Database>()?;
+        Ok(db.create_user(input).await?)
+    }
+
+    async fn delete_user(&self, ctx: &Context<'_>, id: i32) -> Result<bool> {
+        let db = ctx.data::<Database>()?;
+        db.delete_user(id).await?;
+        Ok(true)
+    }
+}
+```
+
+## Subscription
+
+```rust
+use async_graphql::{Subscription, Object};
+use futures_util::Stream;
+
+struct SubscriptionRoot;
+
+#[Subscription]
+impl SubscriptionRoot {
+    async fn messages(&self, room_id: i32) -> impl Stream<Item = Message> {
+        // Return stream of messages
+        tokio_stream::wrappers::BroadcastStream::new(rx)
+            .filter_map(|r| r.ok())
+    }
+}
+```
+
+## DataLoader
+
+```rust
+use async_graphql::dataloader::{DataLoader, Loader};
+use std::collections::HashMap;
+
+struct UserLoader(Database);
+
+impl Loader<i32> for UserLoader {
+    type Value = User;
+    type Error = Error;
+
+    async fn load(&self, keys: &[i32]) -> Result<HashMap<i32, User>, Error> {
+        let users = self.0.users_by_ids(keys).await?;
+        Ok(users.into_iter().map(|u| (u.id, u)).collect())
+    }
+}
+
+// Use in resolver
+#[Object]
+impl Post {
+    async fn author(&self, ctx: &Context<'_>) -> Result<User> {
+        let loader = ctx.data::<DataLoader<UserLoader>>()?;
+        loader.load_one(self.author_id).await?.ok_or("not found".into())
+    }
+}
+
+// Setup
+Schema::build(query, mutation, subscription)
+    .data(DataLoader::new(UserLoader(db), tokio::spawn))
+```
+
+## Error Handling
+
+```rust
+use async_graphql::{Error, ErrorExtensions};
+
+#[Object]
+impl QueryRoot {
+    async fn user(&self, id: i32) -> Result<User> {
+        find_user(id)
+            .await
+            .ok_or_else(|| Error::new("User not found")
+                .extend_with(|_, e| e.set("code", "NOT_FOUND")))
+    }
+}
+
+// Custom error type
+#[derive(thiserror::Error, Debug)]
+enum AppError {
+    #[error("Not found")]
+    NotFound,
+    #[error("Unauthorized")]
+    Unauthorized,
+}
+
+impl ErrorExtensions for AppError {
+    fn extend(&self) -> Error {
+        Error::new(self.to_string()).extend_with(|_, e| {
+            e.set("code", match self {
+                AppError::NotFound => "NOT_FOUND",
+                AppError::Unauthorized => "UNAUTHORIZED",
+            });
+        })
+    }
+}
+```
+
+## Axum Integration
+
+```rust
+use async_graphql_axum::{GraphQLRequest, GraphQLResponse};
+use axum::{Extension, Router, routing::post};
+
+async fn graphql_handler(
+    Extension(schema): Extension<AppSchema>,
+    req: GraphQLRequest,
+) -> GraphQLResponse {
+    schema.execute(req.into_inner()).await.into()
+}
+
+let app = Router::new()
+    .route("/graphql", post(graphql_handler))
+    .layer(Extension(schema));
+```
+
+## Best Practices
+
+1. **DataLoader**: Use for N+1 query prevention
+2. **Context**: Store shared state (DB, auth) in context
+3. **Input validation**: Validate in resolvers, return typed errors
+4. **Pagination**: Use cursor-based pagination for lists
+5. **Subscriptions**: Use for real-time features only

package/rules/rust/async-graphql/references/REFERENCE.md

@@ -0,0 +1,13 @@
+# Async-GraphQL References
+
+## References
+
+- [**Schema Patterns**](schema-patterns.md) - Types, resolvers, subscriptions
+
+## Quick Checks
+
+- [ ] Use derive macros for types
+- [ ] Context for shared state
+- [ ] DataLoader for N+1 prevention
+- [ ] Subscriptions with async streams
+- [ ] Guard for authorization