Schema Authoring SDKs

FraiseQL provides 6 schema authoring SDKs across different programming languages. Each SDK lets you define your GraphQL schema using native language constructs — type annotations, decorators, attributes, or derive macros — which the FraiseQL CLI compiles into an optimized Rust-powered GraphQL API backed by SQL views.

How It Works

You write your schema in your preferred language using native type definitions and decorators/annotations/attributes. The FraiseQL CLI (fraiseql compile) compiles this to a schema.json intermediate representation, which the FraiseQL Rust runtime serves as a GraphQL API — with SQL views (v_*) handling reads and PostgreSQL functions (fn_*) handling mutations.

Your schema (Python/TS/Go/Java/Rust/PHP)
         ↓  fraiseql compile
     schema.json (IR)
         ↓  fraiseql run
   FraiseQL Rust server
         ↓
     PostgreSQL

Available SDKs

Language	Type System	Package Manager	Status
Python	Type hints + decorators	PyPI / uv	Stable
TypeScript	Native types + decorators	npm / yarn / pnpm	Stable
Go	Struct tags + builders	Go modules 1.22+	Stable
Java	Annotations	Maven, Gradle	Stable
Rust	Derive macros	Cargo	Stable
PHP	Attributes (PHP 8.1+)	Composer	Stable

Quick Comparison

import fraiseql
from fraiseql.scalars import ID, Email, DateTime

@fraiseql.type
class User:
    id: ID
    email: Email
    created_at: DateTime

@fraiseql.query(sql_source="v_user")
def users(limit: int = 20) -> list[User]:
    pass

@fraiseql.mutation
def create_user(info, input: CreateUserInput) -> User:
    pass

import { type, query, mutation } from 'fraiseql';

@type()
class User {
  @field() id: ID;
  @field() email: Email;
  @field() createdAt: DateTime;
}

@query({ sqlSource: 'v_user' })
async function users(limit: number = 20): Promise<User[]> {}

@mutation()
async function createUser(info: Context, input: CreateUserInput): Promise<User> {}

// fraiseql:type
type User struct {
    ID        fraiseql.ID       `fraiseql:"id"`
    Email     fraiseql.Email    `fraiseql:"email"`
    CreatedAt fraiseql.DateTime `fraiseql:"created_at"`
}

var Schema = fraiseql.Schema{
    Queries: []fraiseql.Query{
        {Name: "users", SQLSource: "v_user", Returns: []User{}},
    },
    Mutations: []fraiseql.Mutation{
        {Name: "create_user", Input: CreateUserInput{}, Returns: User{}},
    },
}

@FraiseType
public class User {
    public ID id;
    public Email email;
    public DateTime createdAt;
}

public class Queries {
    @FraiseQuery(sqlSource = "v_user")
    public List<User> users(int limit) { return null; }
}

public class Mutations {
    @FraiseMutation
    public User createUser(MutationContext info, CreateUserInput input) { return null; }
}

#[derive(FraiseType, Serialize, Deserialize)]
pub struct User {
    pub id: ID,
    pub email: Email,
    pub created_at: DateTime,
}

#[fraiseql::query(sql_source = "v_user")]
pub async fn users(limit: i32) -> Vec<User> { unreachable!() }

#[fraiseql::mutation]
pub async fn create_user(info: MutationContext, input: CreateUserInput) -> User {
    unreachable!()
}

#[FraiseType]
class User {
    public ID $id;
    public Email $email;
    public DateTime $createdAt;
}

class Queries {
    #[FraiseQuery(sqlSource: 'v_user')]
    public function users(int $limit = 20): array { return []; }
}

class Mutations {
    #[FraiseMutation]
    public function createUser(MutationContext $info, CreateUserInput $input): User {
        return new User();
    }
}

Key Features of All SDKs

Each SDK provides:

Type-safe schema definition — use your language’s native type system
Decorators/attributes/macros — metadata for GraphQL behavior (queries, mutations, authorization)
Input validation — validate inputs at compile time, before deployment
Schema compilation — generate schema.json for the FraiseQL Rust runtime
Full feature parity — all SDKs support the same core feature set
Testing utilities — test clients that run queries against a real database

Choosing an SDK

Python SDK

Best for: data science, scripting, rapid iteration. Primary authoring language.

Python SDK docs

TypeScript SDK

Best for: Node.js backends, full-stack TypeScript teams, frontend-adjacent APIs.

TypeScript SDK docs

Go SDK

Best for: cloud-native microservices, high-throughput APIs, platform engineering.

Go SDK docs

Java SDK

Best for: enterprise backends, Spring Boot teams, JVM polyglot projects.

Java SDK docs

Rust SDK

Best for: maximum performance, systems programming, embedding in Rust applications.

Rust SDK docs

PHP SDK

Best for: Laravel/Symfony teams, web agencies, PHP-first backends.

PHP SDK docs