Feature Creator

This skill guides the creation of a complete feature in QoreDB, ensuring type safety and architectural consistency across the Rust/Tauri/React stack.

Workflow

1. Backend (Rust)

1. •

   Create Command File: Create a new file in src-tauri/src/commands/<feature>.rs using the template below.

   • •Define a [Feature]Response struct deriving Serialize.
   • •Implement the function with #[tauri::command].
   • •Use crate::SharedState if state access involves locking (e.g. state.lock().await).
2. •

   Register Module: In src-tauri/src/lib.rs:

   • •Add pub mod <feature>; in the commands module block (or src-tauri/src/commands/mod.rs if applicable, but QoreDB uses lib.rs for registration).
   • •Add the command to the tauri::generate_handler! macro list.

2. Frontend Interface (TypeScript)

1. •Update src/lib/tauri.ts: This file acts as the central SDK for the backend.
   • •Define the Types (Interfaces) for Arguments and Responses.
   • •Export a typed async function that calls invoke('command_name', { args }).
   • •Rule: Never call invoke directly in components. Always go through src/lib/tauri.ts.

3. Frontend Logic (React)

1. •

   Create Hook (Optional but Recommended): If the feature involves loading states or complex side effects, create src/hooks/use<Feature>.ts.

   • •Use the assets/hook.ts pattern.
2. •

   Implement UI:

   • •Import the function from @lib/tauri (or the hook).
   • •Handle loading and error states explicitly.

Templates

Rust Command (src-tauri/src/commands/)

use serde::Serialize;
use crate::SharedState;

#[derive(Debug, Serialize)]
pub struct FeatureResponse {
    pub success: bool,
    pub data: Option<String>, // Replace with specific type
    pub error: Option<String>,
}

#[tauri::command]
pub async fn feature_command(
    state: tauri::State<'_, SharedState>,
    id: String,
) -> Result<FeatureResponse, String> {
    // Access state:
    // let state = state.lock().await;
    
    Ok(FeatureResponse {
        success: true,
        data: Some("Success".to_string()),
        error: None,
    })
}

TypeScript SDK (src/lib/tauri.ts)

// TYPES
export interface FeatureResponse {
  success: boolean;
  data?: string;
  error?: string;
}

// COMMANDS
export async function featureCommand(id: string): Promise<FeatureResponse> {
  return invoke('feature_command', { id });
}

Checklist

• • Rust: Command created and public
• • Rust: Command registered in generate_handler!
• • TS: Interface defined in src/lib/tauri.ts
• • TS: Wrapper function exported in src/lib/tauri.ts
• • UI: Error handling implemented (Try/Catch or State)