TypedQLiser adds formal type safety to any query language โ SQL, GraphQL, Cypher, SPARQL, KQL, VCL, or anything else โ without modifying the database.
It sits in front of your database as a compile-time type checker. Queries go in, TypedQLiser proves properties about them (no nulls where you donโt expect them, no injection, no type mismatches, resources consumed correctly, transaction protocols followed), and then passes the original query through unchanged. The database never knows itโs there.
This is the highest priority project in the -iser family.
Every database has a query language. None of them have deep type safety:
-
SQL: Runtime type errors, null surprises, injection, no resource tracking
-
GraphQL: Schema types exist but no dependent types, no linearity, no effects
-
Cypher: Pattern matching with no formal verification
-
SPARQL: RDF types are stringly-typed at best
-
VCL: VeriSimDBโs query language has VCL-DT/VCL-total extensions, but theyโre VCL-specific
TypedQLiser makes the type safety portable across all query languages.
| Level | Name | What It Proves |
|---|---|---|
1 |
Parse-time safety |
Query is syntactically valid before reaching the database |
2 |
Schema-binding safety |
All referenced tables/fields/types exist in the schema |
3 |
Type-compatible operations |
No comparing strings to integers, no invalid casts |
4 |
Null-safety |
Every nullable path is explicitly handled; no surprise nulls |
5 |
Injection-proof safety |
No user input can alter query structure (proven, not escaped) |
6 |
Result-type safety |
Return type is known at compile time; no |
| Level | Name | What It Proves |
|---|---|---|
7 |
Cardinality safety |
Query returns exactly N rows, at-most-one, or non-empty (proven) |
8 |
Effect-tracking safety |
Know exactly what side-effects a query produces (reads, writes, deletes) |
9 |
Temporal safety |
Time-dependent queries are valid at the point of execution |
10 |
Linearity safety |
Resources (connections, cursors, transactions) consumed exactly once |
Your application
โ
โผ
typedqliser.toml โโโบ TypedQLiser CLI
โ โ
โ โโโโโโโโโโโโโโผโโโโโโโโโโโโโ
โ โ โ โ
โผ โผ โผ โผ
Query Schema Idris2 Target
Parser Loader Type Kernel Language
(per-lang) (introspect) (proofs) Plugin
โ โ โ โ
โโโโโโฌโโโโโ โ โ
โผ โผ โ
Annotated AST โโโบ Type Check โโโโโโโ
โ โ
โ โโโโโโดโโโโโ
โ โ โ
โผ โผ โผ
Original Proof Error
Query Certificate Report
(unchanged) (.proof) (if fails)Key insight: the original query passes through to the database unchanged. TypedQLiser is a compile-time tool, not a query rewriter. The database sees exactly what it would have seen without TypedQLiser. This means:
-
No performance overhead at runtime
-
No compatibility issues with database versions
-
No risk of query transformation bugs
-
Works with any database that speaks the target query language
TypedQLiser uses a plugin architecture. Each query language gets a parser plugin:
| Language | Databases | Max Level Today | Plugin Status |
|---|---|---|---|
SQL |
PostgreSQL, MySQL, SQLite, MSSQL, Oracle |
6 |
Priority |
GraphQL |
Any GraphQL API |
6 |
Priority |
Cypher |
Neo4j, Memgraph, AGE |
4 |
Planned |
SPARQL |
Any RDF triplestore |
4 |
Planned |
VCL |
VeriSimDB |
10 |
Planned (via VCL-total) |
KQL |
Azure Data Explorer, Kusto |
4 |
Planned |
GQL |
ISO GQL databases |
4 |
Planned |
FQLDT |
Lithoglyph |
10 |
Planned (dependent types native) |
Custom |
User-defined grammar |
varies |
Plugin API |
[typedql]
name = "my-api-queries"
# Which query language to type-check
language = "sql"
# Maximum type safety level to enforce (1-10)
level = 6
# How to load the database schema
schema-source = "introspect" # introspect | file | inline
[database]
# Target database for schema introspection
target-db = "postgresql"
connection-string = "postgres://localhost/mydb"
[paths]
# Where to find queries to type-check
queries = ["src/**/*.sql", "src/**/*.rs"]
# How queries are embedded: standalone files, string literals, or tagged templates
embedding = "string-literal" # standalone | string-literal | tagged-template
[output]
# What to produce
proof-certificates = true # .proof files alongside queries
error-format = "gcc" # gcc | json | sarif | human
ci-mode = false # true = exit code 1 on type errors
[levels]
# Fine-grained control over which levels to enforce vs warn
enforce = [1, 2, 3, 4, 5, 6]
warn = [7, 8]
skip = [9, 10]The core of TypedQLiser is an Idris2 type kernel that encodes the 10 levels as dependent types. Each level is a proof obligation โ the kernel either constructs a proof term (query is safe at that level) or produces a counterexample (hereโs how it could fail).
Key proofs:
* ParseSafe: parse(q) = Right ast (total parser, no panics)
* SchemaBound: โ ref โ ast. ref โ schema (all references resolve)
* TypeCompat: โ op โ ast. types(op.lhs) โก types(op.rhs) (no type mismatches)
* NullSafe: โ path โ ast. nullable(path) โ handled(path) (null paths covered)
* InjectionFree: โ param โ ast. param โ Parameters (no string interpolation)
* ResultTyped: typeof(execute(q, schema)) = T (return type known)
* CardinalitySafe: |execute(q)| โ {0..1, 1, 1..n, n} (row count bounded)
* EffectTracked: effects(q) โ declared_effects (no undeclared side-effects)
* TemporalSafe: valid_at(q, now()) = True (time-dependent predicates hold)
* LinearSafe: consumed(resources(q)) = exactly_once (no leaks, no double-use)
C-ABI bridge between the Idris2 type kernel and the Rust CLI. Handles proof serialisation and AST marshalling.
Each query language is a plugin implementing the QueryLanguagePlugin trait:
pub trait QueryLanguagePlugin: Send + Sync {
/// Parse a query string into a typed AST.
fn parse(&self, query: &str) -> Result<QueryAst>;
/// Load schema from the target database.
fn load_schema(&self, config: &DatabaseConfig) -> Result<Schema>;
/// Extract queries from source files (for embedded queries).
fn extract_queries(&self, source: &str, embedding: Embedding) -> Result<Vec<LocatedQuery>>;
/// Language-specific type rules (e.g., SQL's NULL semantics vs GraphQL's).
fn type_rules(&self) -> &TypeRules;
/// Reconstruct the original query from the AST (for pass-through).
fn reconstruct(&self, ast: &QueryAst) -> Result<String>;
}# Install
cargo install typedqliser
# In your project, create typedqliser.toml (see above)
typedqliser init --language sql --database postgresql
# Type-check all queries in your project
typedqliser check
# Type-check a single query
typedqliser check --query "SELECT * FROM users WHERE id = $1"
# Generate proof certificates
typedqliser check --proofs
# CI mode (exit 1 on errors)
typedqliser check --ci
# Show what level each query achieves
typedqliser info-
TypeLL provides the type theory (10 levels, type kernel, verification protocol)
-
VCL-total applies those levels specifically to VeriSimDBโs VCL
-
TypedQLiser makes them portable to any query language
-
TypedQLiserโs Idris2 kernel can use TypeLL as a shared dependency
-
VCL-total becomes the VCL plugin within TypedQLiser
Pre-alpha. Architecture defined, plugin trait designed, Idris2 proof obligations specified. SQL and GraphQL plugins are priority implementations.
This is the #1 priority -iser project.