@ngxtm/devkit 3.4.0 → 3.4.1

package/rules/rust/sqlx-database/references/REFERENCE.md

@@ -0,0 +1,13 @@
+# SQLx Database References
+
+## References
+
+- [**Query Patterns**](query-patterns.md) - Compile-time checked queries, pooling
+
+## Quick Checks
+
+- [ ] Use sqlx::query! for compile-time checking
+- [ ] Connection pooling with PgPool
+- [ ] Migrations with sqlx-cli
+- [ ] Transaction support
+- [ ] FromRow for custom types

package/rules/rust/sqlx-database/references/query-patterns.md

@@ -0,0 +1,210 @@
+# SQLx Query Patterns
+
+## Connection Pool
+
+```rust
+use sqlx::postgres::PgPoolOptions;
+use sqlx::PgPool;
+
+async fn create_pool() -> Result<PgPool, sqlx::Error> {
+    let pool = PgPoolOptions::new()
+        .max_connections(5)
+        .acquire_timeout(Duration::from_secs(3))
+        .connect(&std::env::var("DATABASE_URL")?)
+        .await?;
+    
+    Ok(pool)
+}
+```
+
+## Compile-Time Checked Queries
+
+```rust
+// Requires DATABASE_URL at compile time
+// Run: cargo sqlx prepare
+
+// Single row
+let user = sqlx::query!(
+    "SELECT id, name, email FROM users WHERE id = $1",
+    user_id
+)
+.fetch_one(&pool)
+.await?;
+
+println!("User: {} - {}", user.name, user.email);
+
+// Multiple rows
+let users = sqlx::query!(
+    "SELECT id, name FROM users WHERE active = $1 LIMIT $2",
+    true,
+    10i64
+)
+.fetch_all(&pool)
+.await?;
+
+// Optional row
+let user = sqlx::query!(
+    "SELECT id, name FROM users WHERE email = $1",
+    email
+)
+.fetch_optional(&pool)
+.await?;
+```
+
+## Query As (Map to Struct)
+
+```rust
+#[derive(sqlx::FromRow)]
+struct User {
+    id: i64,
+    name: String,
+    email: String,
+    created_at: DateTime<Utc>,
+}
+
+let users: Vec<User> = sqlx::query_as!(
+    User,
+    "SELECT id, name, email, created_at FROM users WHERE active = $1",
+    true
+)
+.fetch_all(&pool)
+.await?;
+
+// Or with runtime query
+let users: Vec<User> = sqlx::query_as::<_, User>(
+    "SELECT id, name, email, created_at FROM users"
+)
+.fetch_all(&pool)
+.await?;
+```
+
+## Insert, Update, Delete
+
+```rust
+// Insert with returning
+let user = sqlx::query!(
+    r#"
+    INSERT INTO users (name, email)
+    VALUES ($1, $2)
+    RETURNING id, name, email, created_at
+    "#,
+    name,
+    email
+)
+.fetch_one(&pool)
+.await?;
+
+// Update
+let result = sqlx::query!(
+    "UPDATE users SET name = $1 WHERE id = $2",
+    new_name,
+    user_id
+)
+.execute(&pool)
+.await?;
+
+println!("Rows affected: {}", result.rows_affected());
+
+// Delete
+sqlx::query!("DELETE FROM users WHERE id = $1", user_id)
+    .execute(&pool)
+    .await?;
+```
+
+## Transactions
+
+```rust
+async fn transfer_funds(
+    pool: &PgPool,
+    from: i64,
+    to: i64,
+    amount: i64,
+) -> Result<(), sqlx::Error> {
+    let mut tx = pool.begin().await?;
+
+    sqlx::query!(
+        "UPDATE accounts SET balance = balance - $1 WHERE id = $2",
+        amount,
+        from
+    )
+    .execute(&mut *tx)
+    .await?;
+
+    sqlx::query!(
+        "UPDATE accounts SET balance = balance + $1 WHERE id = $2",
+        amount,
+        to
+    )
+    .execute(&mut *tx)
+    .await?;
+
+    tx.commit().await?;
+    Ok(())
+}
+```
+
+## Streaming
+
+```rust
+use futures::TryStreamExt;
+
+let mut rows = sqlx::query!("SELECT id, name FROM users")
+    .fetch(&pool);
+
+while let Some(row) = rows.try_next().await? {
+    println!("User: {} - {}", row.id, row.name);
+}
+```
+
+## Custom Types
+
+```rust
+#[derive(sqlx::Type)]
+#[sqlx(type_name = "user_role", rename_all = "lowercase")]
+enum UserRole {
+    Admin,
+    User,
+    Guest,
+}
+
+#[derive(sqlx::FromRow)]
+struct User {
+    id: i64,
+    name: String,
+    role: UserRole,
+}
+
+// In query
+let users = sqlx::query_as!(
+    User,
+    r#"SELECT id, name, role as "role: UserRole" FROM users"#
+)
+.fetch_all(&pool)
+.await?;
+```
+
+## Migrations
+
+```bash
+# Install CLI
+cargo install sqlx-cli
+
+# Create migration
+sqlx migrate add create_users
+
+# Run migrations
+sqlx migrate run
+
+# Prepare for offline compilation
+cargo sqlx prepare
+```
+
+```sql
+-- migrations/20240101000000_create_users.sql
+CREATE TABLE users (
+    id BIGSERIAL PRIMARY KEY,
+    name VARCHAR(255) NOT NULL,
+    email VARCHAR(255) UNIQUE NOT NULL,
+    created_at TIMESTAMPTZ DEFAULT NOW()
+);
+```

package/rules/rust/tauri/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: Tauri
+description: Build desktop apps with Rust backend and WebView frontend.
+metadata:
+  labels: [rust, tauri, desktop, webview]
+  triggers:
+    files: ['tauri.conf.json', 'src-tauri/**/*.rs']
+    keywords: [tauri, invoke, command, emit, State]
+---
+
+# Tauri Standards
+
+## Architecture
+
+```
+my-app/
+├── src/                    # Frontend (React/Vue/Svelte)
+├── src-tauri/
+│   ├── Cargo.toml
+│   ├── tauri.conf.json     # Tauri config
+│   ├── src/
+│   │   ├── main.rs         # Entry point
+│   │   └── lib.rs          # Commands
+│   └── icons/
+```
+
+## Commands (Rust → Frontend)
+
+```rust
+use tauri::State;
+
+#[tauri::command]
+fn greet(name: &str) -> String {
+    format!("Hello, {}!", name)
+}
+
+// With state
+#[tauri::command]
+fn get_count(state: State<'_, AppState>) -> u32 {
+    *state.count.lock().unwrap()
+}
+
+// Async command
+#[tauri::command]
+async fn fetch_data(url: String) -> Result<String, String> {
+    reqwest::get(&url)
+        .await
+        .map_err(|e| e.to_string())?
+        .text()
+        .await
+        .map_err(|e| e.to_string())
+}
+
+// Register commands
+fn main() {
+    tauri::Builder::default()
+        .manage(AppState::default())
+        .invoke_handler(tauri::generate_handler![greet, get_count, fetch_data])
+        .run(tauri::generate_context!())
+        .expect("error running app");
+}
+```
+
+## Frontend Invoke
+
+```typescript
+import { invoke } from '@tauri-apps/api/tauri';
+
+// Call Rust command
+const result = await invoke<string>('greet', { name: 'World' });
+
+// With error handling
+try {
+  const data = await invoke<Data>('fetch_data', { url });
+} catch (error) {
+  console.error(error);
+}
+```
+
+## State Management
+
+```rust
+use std::sync::Mutex;
+
+struct AppState {
+    count: Mutex<u32>,
+    db: Mutex<Database>,
+}
+
+impl Default for AppState {
+    fn default() -> Self {
+        Self {
+            count: Mutex::new(0),
+            db: Mutex::new(Database::new()),
+        }
+    }
+}
+
+// Access in commands
+#[tauri::command]
+fn increment(state: State<'_, AppState>) -> u32 {
+    let mut count = state.count.lock().unwrap();
+    *count += 1;
+    *count
+}
+```
+
+## Events
+
+```rust
+use tauri::{AppHandle, Manager};
+
+// Emit from Rust
+#[tauri::command]
+fn start_process(app: AppHandle) {
+    std::thread::spawn(move || {
+        for i in 0..100 {
+            app.emit_all("progress", i).unwrap();
+            std::thread::sleep(Duration::from_millis(100));
+        }
+    });
+}
+
+// Listen in Rust
+app.listen_global("frontend-event", |event| {
+    println!("Received: {:?}", event.payload());
+});
+```
+
+```typescript
+// Listen in frontend
+import { listen } from '@tauri-apps/api/event';
+
+const unlisten = await listen<number>('progress', (event) => {
+  console.log('Progress:', event.payload);
+});
+
+// Emit from frontend
+import { emit } from '@tauri-apps/api/event';
+await emit('frontend-event', { data: 'value' });
+```
+
+## File System
+
+```rust
+use tauri::api::path::app_data_dir;
+
+#[tauri::command]
+fn save_config(app: AppHandle, config: Config) -> Result<(), String> {
+    let path = app_data_dir(&app.config())
+        .ok_or("No app data dir")?
+        .join("config.json");
+
+    std::fs::write(&path, serde_json::to_string(&config).unwrap())
+        .map_err(|e| e.to_string())
+}
+```
+
+## Permissions (tauri.conf.json)
+
+```json
+{
+  "tauri": {
+    "allowlist": {
+      "fs": { "all": true, "scope": ["$APP/*"] },
+      "shell": { "open": true },
+      "dialog": { "all": true },
+      "http": { "all": true, "scope": ["https://api.example.com/*"] }
+    }
+  }
+}
+```
+
+## Best Practices
+
+1. **Commands**: Keep thin, delegate to services
+2. **State**: Use `Mutex` for shared state, avoid long locks
+3. **Errors**: Return `Result<T, String>` for frontend handling
+4. **Async**: Use async commands for I/O operations
+5. **Security**: Scope file/http access in allowlist

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

@@ -0,0 +1,13 @@
+# Tauri Desktop References
+
+## References
+
+- [**Command Patterns**](command-patterns.md) - IPC, state, events
+
+## Quick Checks
+
+- [ ] Use #[tauri::command] for IPC
+- [ ] Manage state with State<>
+- [ ] Emit events for async updates
+- [ ] Window management
+- [ ] File system access with APIs

package/rules/rust/tauri/references/command-patterns.md

@@ -0,0 +1,209 @@
+# Tauri Command Patterns
+
+## Basic Commands
+
+```rust
+use tauri::command;
+
+#[command]
+fn greet(name: &str) -> String {
+    format!("Hello, {}!", name)
+}
+
+#[command]
+async fn fetch_data(url: String) -> Result<String, String> {
+    reqwest::get(&url)
+        .await
+        .map_err(|e| e.to_string())?
+        .text()
+        .await
+        .map_err(|e| e.to_string())
+}
+
+fn main() {
+    tauri::Builder::default()
+        .invoke_handler(tauri::generate_handler![greet, fetch_data])
+        .run(tauri::generate_context!())
+        .expect("error running app");
+}
+```
+
+## State Management
+
+```rust
+use std::sync::Mutex;
+use tauri::State;
+
+struct AppState {
+    counter: Mutex<i32>,
+    db: Database,
+}
+
+#[command]
+fn increment(state: State<AppState>) -> i32 {
+    let mut counter = state.counter.lock().unwrap();
+    *counter += 1;
+    *counter
+}
+
+#[command]
+async fn get_users(state: State<'_, AppState>) -> Result<Vec<User>, String> {
+    state.db.get_users()
+        .await
+        .map_err(|e| e.to_string())
+}
+
+fn main() {
+    let state = AppState {
+        counter: Mutex::new(0),
+        db: Database::new(),
+    };
+
+    tauri::Builder::default()
+        .manage(state)
+        .invoke_handler(tauri::generate_handler![increment, get_users])
+        .run(tauri::generate_context!())
+        .unwrap();
+}
+```
+
+## Events
+
+```rust
+use tauri::{Manager, Window};
+
+#[command]
+fn start_download(window: Window, url: String) {
+    std::thread::spawn(move || {
+        for progress in 0..=100 {
+            std::thread::sleep(std::time::Duration::from_millis(50));
+            window.emit("download-progress", progress).unwrap();
+        }
+        window.emit("download-complete", ()).unwrap();
+    });
+}
+
+// In frontend (JavaScript)
+// import { listen } from '@tauri-apps/api/event';
+// await listen('download-progress', (event) => {
+//     console.log('Progress:', event.payload);
+// });
+```
+
+## Window Management
+
+```rust
+use tauri::{Manager, WindowBuilder, WindowUrl};
+
+#[command]
+async fn open_settings(app: tauri::AppHandle) -> Result<(), String> {
+    WindowBuilder::new(
+        &app,
+        "settings",
+        WindowUrl::App("settings.html".into())
+    )
+    .title("Settings")
+    .inner_size(600.0, 400.0)
+    .resizable(false)
+    .build()
+    .map_err(|e| e.to_string())?;
+    
+    Ok(())
+}
+
+#[command]
+fn close_window(window: Window) {
+    window.close().unwrap();
+}
+
+#[command]
+fn minimize_window(window: Window) {
+    window.minimize().unwrap();
+}
+```
+
+## File Operations
+
+```rust
+use std::fs;
+use tauri::api::path::app_data_dir;
+
+#[command]
+fn read_config(app: tauri::AppHandle) -> Result<String, String> {
+    let config_dir = app_data_dir(&app.config())
+        .ok_or("Failed to get app data dir")?;
+    let config_path = config_dir.join("config.json");
+    
+    fs::read_to_string(config_path)
+        .map_err(|e| e.to_string())
+}
+
+#[command]
+fn save_config(app: tauri::AppHandle, config: String) -> Result<(), String> {
+    let config_dir = app_data_dir(&app.config())
+        .ok_or("Failed to get app data dir")?;
+    
+    fs::create_dir_all(&config_dir)
+        .map_err(|e| e.to_string())?;
+    
+    fs::write(config_dir.join("config.json"), config)
+        .map_err(|e| e.to_string())
+}
+```
+
+## Menu and System Tray
+
+```rust
+use tauri::{CustomMenuItem, Menu, MenuItem, Submenu, SystemTray, SystemTrayMenu};
+
+fn main() {
+    let menu = Menu::new()
+        .add_submenu(Submenu::new(
+            "File",
+            Menu::new()
+                .add_item(CustomMenuItem::new("open", "Open"))
+                .add_native_item(MenuItem::Separator)
+                .add_item(CustomMenuItem::new("quit", "Quit")),
+        ));
+
+    let tray_menu = SystemTrayMenu::new()
+        .add_item(CustomMenuItem::new("show", "Show"))
+        .add_item(CustomMenuItem::new("quit", "Quit"));
+
+    let tray = SystemTray::new().with_menu(tray_menu);
+
+    tauri::Builder::default()
+        .menu(menu)
+        .system_tray(tray)
+        .on_menu_event(|event| {
+            match event.menu_item_id() {
+                "quit" => std::process::exit(0),
+                "open" => { /* handle open */ }
+                _ => {}
+            }
+        })
+        .on_system_tray_event(|app, event| {
+            // Handle tray events
+        })
+        .run(tauri::generate_context!())
+        .unwrap();
+}
+```
+
+## Frontend Integration
+
+```typescript
+// In frontend (TypeScript)
+import { invoke } from '@tauri-apps/api/tauri';
+
+// Call commands
+const greeting = await invoke<string>('greet', { name: 'World' });
+const users = await invoke<User[]>('get_users');
+
+// With error handling
+try {
+    const data = await invoke('fetch_data', { url: 'https://api.example.com' });
+} catch (error) {
+    console.error('Failed:', error);
+}
+```