@ngxtm/devkit 3.3.0 → 3.4.1

package/rules/rust/async-graphql/references/schema-patterns.md

@@ -0,0 +1,215 @@
+# Async-GraphQL Schema Patterns
+
+## Basic Types
+
+```rust
+use async_graphql::*;
+
+#[derive(SimpleObject)]
+struct User {
+    id: ID,
+    name: String,
+    email: String,
+    #[graphql(skip)]
+    password_hash: String, // Hidden from schema
+}
+
+// Complex object with resolvers
+#[derive(Default)]
+struct Post {
+    id: i64,
+    title: String,
+    author_id: i64,
+}
+
+#[Object]
+impl Post {
+    async fn id(&self) -> ID {
+        self.id.into()
+    }
+
+    async fn title(&self) -> &str {
+        &self.title
+    }
+
+    // Resolver with context
+    async fn author(&self, ctx: &Context<'_>) -> Result<User> {
+        let db = ctx.data::<Database>()?;
+        db.find_user(self.author_id)
+            .await
+            .ok_or_else(|| Error::new("Author not found"))
+    }
+}
+
+// Input types
+#[derive(InputObject)]
+struct CreatePostInput {
+    title: String,
+    content: String,
+}
+
+// Enums
+#[derive(Enum, Copy, Clone, Eq, PartialEq)]
+enum PostStatus {
+    Draft,
+    Published,
+    Archived,
+}
+```
+
+## Query and Mutation
+
+```rust
+struct Query;
+
+#[Object]
+impl Query {
+    async fn user(&self, ctx: &Context<'_>, id: ID) -> Result<Option<User>> {
+        let db = ctx.data::<Database>()?;
+        Ok(db.find_user(id.parse()?).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)
+    }
+}
+
+struct Mutation;
+
+#[Object]
+impl Mutation {
+    async fn create_post(
+        &self,
+        ctx: &Context<'_>,
+        input: CreatePostInput,
+    ) -> Result<Post> {
+        let db = ctx.data::<Database>()?;
+        let user = ctx.data::<CurrentUser>()?;
+        
+        db.create_post(user.id, &input.title, &input.content).await
+    }
+
+    async fn delete_post(&self, ctx: &Context<'_>, id: ID) -> Result<bool> {
+        let db = ctx.data::<Database>()?;
+        Ok(db.delete_post(id.parse()?).await?)
+    }
+}
+```
+
+## Subscriptions
+
+```rust
+use async_graphql::*;
+use futures_util::Stream;
+
+struct Subscription;
+
+#[Subscription]
+impl Subscription {
+    async fn posts(&self, ctx: &Context<'_>) -> impl Stream<Item = Post> {
+        let rx = ctx.data::<broadcast::Receiver<Post>>().unwrap().resubscribe();
+        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 {
+    db: Database,
+}
+
+#[async_trait::async_trait]
+impl Loader<i64> for UserLoader {
+    type Value = User;
+    type Error = async_graphql::Error;
+
+    async fn load(&self, keys: &[i64]) -> Result<HashMap<i64, Self::Value>, Self::Error> {
+        let users = self.db.find_users_by_ids(keys).await?;
+        Ok(users.into_iter().map(|u| (u.id, u)).collect())
+    }
+}
+
+#[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_else(|| Error::new("Author not found"))
+    }
+}
+```
+
+## Guards (Authorization)
+
+```rust
+use async_graphql::*;
+
+struct RoleGuard {
+    role: Role,
+}
+
+#[async_trait::async_trait]
+impl Guard for RoleGuard {
+    async fn check(&self, ctx: &Context<'_>) -> Result<()> {
+        let user = ctx.data::<CurrentUser>()?;
+        if user.role >= self.role {
+            Ok(())
+        } else {
+            Err("Forbidden".into())
+        }
+    }
+}
+
+#[Object]
+impl Mutation {
+    #[graphql(guard = "RoleGuard { role: Role::Admin }")]
+    async fn delete_user(&self, ctx: &Context<'_>, id: ID) -> Result<bool> {
+        // Only admins can access
+        Ok(true)
+    }
+}
+```
+
+## Integration with Axum
+
+```rust
+use async_graphql_axum::{GraphQLRequest, GraphQLResponse};
+use axum::{extract::State, routing::post, Router};
+
+async fn graphql_handler(
+    State(schema): State<Schema<Query, Mutation, Subscription>>,
+    req: GraphQLRequest,
+) -> GraphQLResponse {
+    schema.execute(req.into_inner()).await.into()
+}
+
+#[tokio::main]
+async fn main() {
+    let schema = Schema::build(Query, Mutation, Subscription)
+        .data(Database::new())
+        .data(DataLoader::new(UserLoader::new(), tokio::spawn))
+        .finish();
+
+    let app = Router::new()
+        .route("/graphql", post(graphql_handler))
+        .with_state(schema);
+
+    axum::Server::bind(&"0.0.0.0:8080".parse().unwrap())
+        .serve(app.into_make_service())
+        .await
+        .unwrap();
+}
+```

package/rules/rust/axum/SKILL.md

@@ -0,0 +1,161 @@
+---
+name: Axum Framework
+description: Ergonomic Rust web framework built on Tower and Tokio.
+metadata:
+  labels: [rust, axum, web, framework, tower]
+  triggers:
+    files: ['**/main.rs', '**/routes/*.rs']
+    keywords: [axum, Router, Extension, State]
+---
+
+# Axum Standards
+
+## Router Setup
+
+```rust
+use axum::{Router, routing::{get, post}, Extension};
+
+#[tokio::main]
+async fn main() {
+    let app = Router::new()
+        .route("/", get(root))
+        .route("/users", get(list_users).post(create_user))
+        .route("/users/:id", get(get_user))
+        .nest("/api", api_routes())
+        .layer(Extension(db_pool))
+        .layer(TraceLayer::new_for_http());
+
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
+    axum::serve(listener, app).await.unwrap();
+}
+```
+
+## Extractors
+
+```rust
+use axum::{
+    extract::{Path, Query, State, Json},
+    http::StatusCode,
+};
+
+// Path parameters
+async fn get_user(Path(id): Path<u64>) -> impl IntoResponse {
+    Json(user)
+}
+
+// Query parameters
+async fn list(Query(params): Query<Pagination>) -> impl IntoResponse {
+    Json(items)
+}
+
+// JSON body
+async fn create(Json(payload): Json<CreateUser>) -> impl IntoResponse {
+    (StatusCode::CREATED, Json(user))
+}
+
+// State (shared application state)
+async fn handler(State(pool): State<PgPool>) -> impl IntoResponse {
+    let conn = pool.acquire().await?;
+    Json(result)
+}
+```
+
+## State Management
+
+```rust
+#[derive(Clone)]
+struct AppState {
+    db: PgPool,
+    cache: RedisPool,
+}
+
+let state = AppState { db, cache };
+
+let app = Router::new()
+    .route("/users", get(handler))
+    .with_state(state);
+
+async fn handler(State(state): State<AppState>) -> impl IntoResponse {
+    // Access state.db, state.cache
+}
+```
+
+## Error Handling
+
+```rust
+use axum::{
+    response::{IntoResponse, Response},
+    http::StatusCode,
+};
+
+enum AppError {
+    NotFound,
+    Database(sqlx::Error),
+}
+
+impl IntoResponse for AppError {
+    fn into_response(self) -> Response {
+        let (status, message) = match self {
+            AppError::NotFound => (StatusCode::NOT_FOUND, "Not found"),
+            AppError::Database(_) => (StatusCode::INTERNAL_SERVER_ERROR, "Database error"),
+        };
+        (status, Json(json!({ "error": message }))).into_response()
+    }
+}
+
+// Handler returns Result<T, AppError>
+async fn handler() -> Result<Json<User>, AppError> {
+    let user = db.find(id).await.map_err(AppError::Database)?;
+    user.ok_or(AppError::NotFound).map(Json)
+}
+```
+
+## Middleware (Tower Layers)
+
+```rust
+use tower_http::{
+    trace::TraceLayer,
+    cors::CorsLayer,
+    compression::CompressionLayer,
+};
+
+let app = Router::new()
+    .route("/", get(handler))
+    .layer(TraceLayer::new_for_http())
+    .layer(CompressionLayer::new())
+    .layer(CorsLayer::permissive());
+
+// Custom middleware
+async fn auth_layer<B>(
+    req: Request<B>,
+    next: Next<B>,
+) -> Result<Response, StatusCode> {
+    let token = req.headers().get("Authorization");
+    // Validate token
+    Ok(next.run(req).await)
+}
+```
+
+## Testing
+
+```rust
+use axum::http::StatusCode;
+use axum_test::TestServer;
+
+#[tokio::test]
+async fn test_get_user() {
+    let app = create_app();
+    let server = TestServer::new(app).unwrap();
+
+    let response = server.get("/users/1").await;
+
+    assert_eq!(response.status_code(), StatusCode::OK);
+}
+```
+
+## Best Practices
+
+1. **State**: Use `State<T>` over `Extension<T>` for type safety
+2. **Extractors**: Order matters - put fallible extractors last
+3. **Layers**: Apply common layers at router level, not per-route
+4. **Errors**: Implement `IntoResponse` for custom error types

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

@@ -0,0 +1,14 @@
+# Axum References
+
+## References
+
+- [**Handler Patterns**](handler-patterns.md) - Extractors, responses, error handling
+- [**Middleware**](middleware.md) - Tower layers, authentication, tracing
+
+## Quick Checks
+
+- [ ] Use extractors for request data (Json, Path, Query)
+- [ ] Return IntoResponse types
+- [ ] Use State for shared application state
+- [ ] Tower layers for middleware
+- [ ] Type-safe routing with typed paths

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

@@ -0,0 +1,97 @@
+# Axum Handler Patterns
+
+## Basic Handlers
+
+```rust
+use axum::{
+    extract::{Path, Query, State, Json},
+    http::StatusCode,
+    response::IntoResponse,
+    routing::{get, post},
+    Router,
+};
+
+// GET with path parameter
+async fn get_user(Path(id): Path<i64>) -> impl IntoResponse {
+    Json(User { id, name: "John".into() })
+}
+
+// POST with JSON body
+async fn create_user(
+    State(db): State<Database>,
+    Json(payload): Json<CreateUserRequest>,
+) -> Result<impl IntoResponse, AppError> {
+    let user = db.create_user(&payload).await?;
+    Ok((StatusCode::CREATED, Json(user)))
+}
+
+// Query parameters
+async fn list_users(
+    Query(params): Query<ListParams>,
+) -> impl IntoResponse {
+    Json(vec![/* users */])
+}
+
+// Router setup
+fn app(db: Database) -> Router {
+    Router::new()
+        .route("/users", get(list_users).post(create_user))
+        .route("/users/:id", get(get_user))
+        .with_state(db)
+}
+```
+
+## Error Handling
+
+```rust
+use axum::{
+    http::StatusCode,
+    response::{IntoResponse, Response},
+    Json,
+};
+
+pub enum AppError {
+    NotFound,
+    BadRequest(String),
+    Internal(anyhow::Error),
+}
+
+impl IntoResponse for AppError {
+    fn into_response(self) -> Response {
+        let (status, message) = match self {
+            AppError::NotFound => (StatusCode::NOT_FOUND, "Not found".into()),
+            AppError::BadRequest(msg) => (StatusCode::BAD_REQUEST, msg),
+            AppError::Internal(e) => {
+                tracing::error!("Internal error: {:?}", e);
+                (StatusCode::INTERNAL_SERVER_ERROR, "Internal error".into())
+            }
+        };
+
+        (status, Json(serde_json::json!({ "error": message }))).into_response()
+    }
+}
+
+// Usage in handler
+async fn get_user(Path(id): Path<i64>) -> Result<Json<User>, AppError> {
+    let user = find_user(id).await.ok_or(AppError::NotFound)?;
+    Ok(Json(user))
+}
+```
+
+## Middleware with Tower
+
+```rust
+use tower_http::{
+    cors::CorsLayer,
+    trace::TraceLayer,
+    compression::CompressionLayer,
+};
+
+fn app() -> Router {
+    Router::new()
+        .route("/", get(root))
+        .layer(TraceLayer::new_for_http())
+        .layer(CompressionLayer::new())
+        .layer(CorsLayer::permissive())
+}
+```

package/rules/rust/bevy/SKILL.md

@@ -0,0 +1,206 @@
+---
+name: Bevy Game Engine
+description: Data-driven game engine with ECS architecture.
+metadata:
+  labels: [rust, bevy, game, ecs]
+  triggers:
+    files: ['**/main.rs', 'assets/**']
+    keywords: [bevy, App, Component, Query, Resource, Commands]
+---
+
+# Bevy Standards
+
+## App Setup
+
+```rust
+use bevy::prelude::*;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .add_systems(Update, (movement, collision).chain())
+        .run();
+}
+
+fn setup(mut commands: Commands) {
+    commands.spawn(Camera2dBundle::default());
+}
+```
+
+## Components
+
+```rust
+#[derive(Component)]
+struct Player {
+    speed: f32,
+}
+
+#[derive(Component)]
+struct Health(u32);
+
+#[derive(Component)]
+struct Velocity(Vec2);
+
+// Spawn entity with components
+fn spawn_player(mut commands: Commands) {
+    commands.spawn((
+        Player { speed: 200.0 },
+        Health(100),
+        Velocity(Vec2::ZERO),
+        SpriteBundle {
+            transform: Transform::from_xyz(0.0, 0.0, 0.0),
+            ..default()
+        },
+    ));
+}
+```
+
+## Systems
+
+```rust
+// Query components
+fn movement(
+    time: Res<Time>,
+    input: Res<Input<KeyCode>>,
+    mut query: Query<(&Player, &mut Transform, &mut Velocity)>,
+) {
+    for (player, mut transform, mut velocity) in &mut query {
+        let mut direction = Vec2::ZERO;
+        if input.pressed(KeyCode::W) { direction.y += 1.0; }
+        if input.pressed(KeyCode::S) { direction.y -= 1.0; }
+        if input.pressed(KeyCode::A) { direction.x -= 1.0; }
+        if input.pressed(KeyCode::D) { direction.x += 1.0; }
+
+        velocity.0 = direction.normalize_or_zero() * player.speed;
+        transform.translation += velocity.0.extend(0.0) * time.delta_seconds();
+    }
+}
+
+// Filter queries
+fn damage_enemies(
+    mut query: Query<&mut Health, (With<Enemy>, Without<Player>)>,
+) {
+    for mut health in &mut query {
+        health.0 = health.0.saturating_sub(10);
+    }
+}
+```
+
+## Resources
+
+```rust
+#[derive(Resource)]
+struct GameState {
+    score: u32,
+    level: u32,
+}
+
+#[derive(Resource, Default)]
+struct GameAssets {
+    player_texture: Handle<Image>,
+}
+
+// Insert resource
+app.insert_resource(GameState { score: 0, level: 1 });
+
+// Access in system
+fn update_score(mut state: ResMut<GameState>) {
+    state.score += 10;
+}
+```
+
+## Events
+
+```rust
+#[derive(Event)]
+struct CollisionEvent {
+    entity_a: Entity,
+    entity_b: Entity,
+}
+
+// Send event
+fn detect_collision(mut events: EventWriter<CollisionEvent>) {
+    events.send(CollisionEvent { entity_a, entity_b });
+}
+
+// Read events
+fn handle_collision(mut events: EventReader<CollisionEvent>) {
+    for event in events.read() {
+        println!("Collision: {:?} <-> {:?}", event.entity_a, event.entity_b);
+    }
+}
+
+// Register event
+app.add_event::<CollisionEvent>();
+```
+
+## States
+
+```rust
+#[derive(States, Debug, Clone, Eq, PartialEq, Hash, Default)]
+enum GameState {
+    #[default]
+    Menu,
+    Playing,
+    Paused,
+    GameOver,
+}
+
+app.add_state::<GameState>()
+   .add_systems(OnEnter(GameState::Playing), start_game)
+   .add_systems(OnExit(GameState::Playing), cleanup_game)
+   .add_systems(Update, game_logic.run_if(in_state(GameState::Playing)));
+
+// Change state
+fn pause_game(mut next_state: ResMut<NextState<GameState>>) {
+    next_state.set(GameState::Paused);
+}
+```
+
+## Assets
+
+```rust
+fn load_assets(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+) {
+    let texture = asset_server.load("player.png");
+    commands.insert_resource(GameAssets { player_texture: texture });
+}
+
+// Spawn with texture
+fn spawn_sprite(
+    mut commands: Commands,
+    assets: Res<GameAssets>,
+) {
+    commands.spawn(SpriteBundle {
+        texture: assets.player_texture.clone(),
+        ..default()
+    });
+}
+```
+
+## Plugins
+
+```rust
+pub struct PlayerPlugin;
+
+impl Plugin for PlayerPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(Startup, spawn_player)
+           .add_systems(Update, (movement, animation));
+    }
+}
+
+// Use plugin
+app.add_plugins(PlayerPlugin);
+```
+
+## Best Practices
+
+1. **ECS**: Prefer composition over inheritance
+2. **Systems**: Keep small, single responsibility
+3. **Queries**: Use filters (`With`, `Without`) for performance
+4. **Resources**: For global state, not per-entity data
+5. **Events**: Decouple systems, avoid direct dependencies

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

@@ -0,0 +1,13 @@
+# Bevy Game Engine References
+
+## References
+
+- [**ECS Patterns**](ecs-patterns.md) - Entities, components, systems
+
+## Quick Checks
+
+- [ ] Use ECS architecture (Entity-Component-System)
+- [ ] Resources for global state
+- [ ] Events for communication
+- [ ] States for game flow
+- [ ] Assets for loading resources