SQL Connect

Data Layer Generation

Generate complete, type-safe data layers from your database schema. FastAPI, .NET Core, Node.js, and Next.js with SAGA pattern support for distributed transactions.

Supported Frameworks

🐍

FastAPI

Python async API with Pydantic models

💜

.NET Core

C# Web API with Entity Framework

💚

Node.js

Express/Fastify with TypeScript

▲

Next.js

API routes with tRPC support

Generated Components

API Layer

RESTful endpoints for all tables
Stored procedure endpoints
OpenAPI/Swagger documentation
Authentication middleware

Type Definitions

TypeScript interfaces
Zod validation schemas
Pydantic models (Python)
C# DTOs and records

Frontend Clients

React Query hooks
Vue composables
Python SDK client
tRPC client/server

SAGA Support

Distributed transaction handling
Compensation logic
State machine tracking
Retry and rollback

Sample Generated Code

# Generated FastAPI endpoint
from fastapi import APIRouter, Depends, HTTPException
from pydantic import BaseModel
from typing import List, Optional
from datetime import datetime

router = APIRouter(prefix="/customers", tags=["customers"])

class Customer(BaseModel):
    customer_id: int
    first_name: str
    last_name: str
    email: str
    created_at: datetime

class CustomerCreate(BaseModel):
    first_name: str
    last_name: str
    email: str

@router.get("/", response_model=List[Customer])
async def list_customers(
    skip: int = 0,
    limit: int = 100,
    db: Database = Depends(get_db)
):
    """List all customers with pagination."""
    return await db.fetch_all(
        "SELECT * FROM Customers ORDER BY customer_id OFFSET :skip ROWS FETCH NEXT :limit ROWS ONLY",
        {"skip": skip, "limit": limit}
    )

@router.post("/", response_model=Customer)
async def create_customer(
    customer: CustomerCreate,
    db: Database = Depends(get_db)
):
    """Create a new customer."""
    result = await db.execute(
        "EXEC dbo.CreateCustomer @FirstName=:first_name, @LastName=:last_name, @Email=:email",
        customer.dict()
    )
    return await db.fetch_one("SELECT * FROM Customers WHERE customer_id = :id", {"id": result})

Configuration-Driven

Define your API structure in JSON or use the database table for dynamic operations

{
  "api_operations": [
    {
      "name": "GetCustomerOrders",
      "method": "GET",
      "path": "/customers/{customerId}/orders",
      "procedure": "dbo.GetCustomerOrders",
      "parameters": [
        {"name": "customerId", "type": "int", "source": "path"}
      ],
      "response": {
        "type": "array",
        "schema": "Order"
      }
    },
    {
      "name": "ProcessPayment",
      "method": "POST",
      "path": "/payments",
      "saga": {
        "enabled": true,
        "steps": [
          {"action": "ValidatePayment", "compensation": "VoidPayment"},
          {"action": "DeductInventory", "compensation": "RestoreInventory"},
          {"action": "CreateShipment", "compensation": "CancelShipment"}
        ]
      }
    }
  ]
}

Generate Your API Layer

Type-safe APIs with SAGA pattern support, generated and maintained automatically.

Start Free Trial View All Features

No credit card required • Free for individual developers