OpenParable
Skip to content
← Back to skills

Turbo Route

Development
turbo-route

Turbo Route is an Agent Skill for development published in the justrach/turboAPI repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Scaffold a new TurboAPI route with handler, model, and tests. Use when adding a new API endpoint, creating a new route, or scaffolding CRUD for a resource.

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/justrach/turboAPI/blob/HEAD/.claude/skills/turbo-route/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/turbo-route, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

Scaffold a TurboAPI Route

Create a new route for the TurboAPI application based on the resource name and HTTP method.

Steps

  1. Determine the resource: Use $ARGUMENTS[0] as the resource name (e.g., users, items, orders)
  2. Determine the method: Use $ARGUMENTS[1] if provided, otherwise scaffold all CRUD methods (GET, POST, PUT, DELETE)
  3. Check existing routes: Read python/turboapi/zig_integration.py to understand the current route registration pattern
  4. Create the model: If it's a POST/PUT route, create a dhi BaseModel for the request body

Template

For each route, generate code following this pattern:

from turboapi import TurboAPI
from dhi import BaseModel, Field

app = TurboAPI()

class {Resource}(BaseModel):
    # fields based on resource name
    name: str = Field(min_length=1, max_length=100)

@app.get("/{resource_plural}")
def list_{resource_plural}():
    return {"{resource_plural}": []}

@app.get("/{resource_plural}/{{{resource}_id}}")
def get_{resource}({resource}_id: int):
    return {"{resource}_id": {resource}_id}

@app.post("/{resource_plural}")
def create_{resource}({resource}: {Resource}):
    return {"{resource}": {resource}.model_dump(), "created": True}

@app.delete("/{resource_plural}/{{{resource}_id}}")
def delete_{resource}({resource}_id: int):
    return {"deleted": True}

Also generate a test file

Create tests/test_{resource_plural}.py with TestClient-based tests for each endpoint. Include both success and error cases.

Handler classification

When creating routes, note which Zig dispatch path they'll use:

  • No params, sync → simple_sync_noargs (fastest, cached)
  • Path/query params, sync → simple_sync (vectorcall)
  • Body with dhi model → model_sync (Zig-native validation)
  • Depends() or middleware → enhanced (full Python)