Code Generators

kit make:controller <name>

kit make:controller User
kit make:controller OrderItem
kit make:controller api/User

// src/controllers/user.rs
use kit::{handler, json_response, Request, Response};

#[handler]
pub async fn invoke(_req: Request) -> Response {
    json_response!({
        "controller": "User"
    })
}

kit make:action <name>

kit make:action CreateUser
kit make:action SendNotification
kit make:action ProcessPayment

// src/actions/create_user.rs
use kit::injectable;

#[injectable]
pub struct CreateUserAction {
    // Dependencies injected via container
}

impl CreateUserAction {
    pub fn execute(&self) {
        // TODO: Implement action logic
    }
}

kit make:middleware <name>

kit make:middleware Auth
kit make:middleware RateLimit
kit make:middleware Cors

// src/middleware/auth.rs
use kit::middleware::{Middleware, Next};
use kit::{Request, Response};
use async_trait::async_trait;

pub struct AuthMiddleware;

#[async_trait]
impl Middleware for AuthMiddleware {
    async fn handle(&self, req: Request, next: Next) -> Response {
        // Before request handling

        let response = next.run(req).await;

        // After request handling

        response
    }
}

kit make:error <name>

kit make:error UserNotFound
kit make:error PaymentFailed
kit make:error InsufficientStock

// src/errors/user_not_found.rs
use kit::domain_error;

#[domain_error(status = 500, message = "User not found")]
pub struct UserNotFound;

use crate::errors::user_not_found::UserNotFound;

pub async fn show(req: Request) -> Response {
    let user = find_user(id).await
        .ok_or(UserNotFound)?;  // Returns 500 response

    json_response!({ "user": user })
}

kit make:task <name>

kit make:task CleanupLogs
kit make:task SendReminders
kit make:task BackupDatabase

// src/tasks/cleanup_logs_task.rs
use async_trait::async_trait;
use kit::{Task, TaskResult};

/// CleanupLogsTask - A scheduled task
///
/// Implement your task logic in the `handle()` method.
/// Register this task in `src/schedule.rs` with the fluent API.
pub struct CleanupLogsTask;

impl CleanupLogsTask {
    pub fn new() -> Self {
        Self
    }
}

#[async_trait]
impl Task for CleanupLogsTask {
    async fn handle(&self) -> TaskResult {
        // TODO: Implement your task logic here
        println!("Running CleanupLogsTask...");
        Ok(())
    }
}

use crate::tasks::cleanup_logs_task;

pub fn register(schedule: &mut Schedule) {
    schedule.add(
        schedule.task(cleanup_logs_task::CleanupLogsTask::new())
            .daily()
            .at("03:00")
            .name("cleanup_logs_task")
            .description("TODO: Add task description")
    );
}

kit schedule:work  # Daemon mode
kit schedule:run   # Run once

kit make:inertia <name>

kit make:inertia About
kit make:inertia UserProfile
kit make:inertia Dashboard

// frontend/src/pages/About.tsx
export default function About() {
    return (
        <div>
            <h1>About</h1>
        </div>
    );
}

kit generate-types [options]

# Generate types once
kit generate-types

# Watch mode
kit generate-types --watch

# Custom output path
kit generate-types --output frontend/src/types/props.ts

// Rust
#[derive(InertiaProps)]
pub struct UserPageProps {
    pub user: User,
    pub posts: Vec<Post>,
}

// Generated TypeScript
export interface UserPageProps {
    user: User;
    posts: Post[];
}