TypeORM ClickHouse
Looking for TypeORM on ClickHouse?
TypeORM is built around relational entities, transactions, and table relationships. ClickHouse is a columnar analytics database with a different type model and a different query shape. If what you actually want is a TypeScript workflow for ClickHouse analytics, hypequery is the closer fit.
TypeORM fit
Relational app databases
hypequery fit
ClickHouse analytics workloads
Type source
Generated from live schema
TypeORM models entities and relations, not ClickHouse analytics workflows
TypeORM is strong when your database behaves like Postgres or MySQL. ClickHouse is optimized for append-heavy analytics, large scans, and aggregation rather than entity graphs and row-level transactional updates.
ClickHouse runtime values do not match normal ORM assumptions
DateTime values come back as strings, UInt64 values come back as strings to avoid precision loss, and ClickHouse-specific clauses like PREWHERE and ARRAY JOIN do not fit neatly into a traditional ORM abstraction.
Analytics teams usually need reusable delivery paths as well as typed queries
Once ClickHouse data powers app features, internal tools, and dashboards, the problem becomes shared query definitions and safe reuse, not just entity mapping.
What to use
Use hypequery as the ClickHouse-native TypeScript layer
hypequery gives you the part of the TypeORM experience that matters for ClickHouse: schema-generated types, fluent queries in TypeScript, and a path to reuse those query definitions across scripts, HTTP endpoints, and frontend code.
- Generate TypeScript types from your live ClickHouse schema
- Use a composable query builder built for ClickHouse query patterns
- Keep runtime type mappings accurate: DateTime, UInt64, Decimal, Nullable
- Promote queries into typed REST endpoints and OpenAPI docs when teams need shared delivery
- Use React hooks on the same query contract when dashboards need the same data
Step 1
Generate types from the real schema
This keeps TypeScript aligned with actual ClickHouse runtime behaviour instead of forcing relational ORM conventions onto a columnar engine.
Step 2
Write typed ClickHouse queries instead of entity-oriented ORM code
ClickHouse-heavy TypeScript applications usually want composable queries, aggregation helpers, and safe reuse of query logic. hypequery stays close to that shape rather than abstracting it behind entity patterns.
If your stack already uses TypeORM with Postgres or MySQL, the clean split is often TypeORM for transactional application data and hypequery for ClickHouse analytics.
That keeps each tool aligned to the database shape it was built for instead of forcing one abstraction to cover two very different systems.
Step 2
Query ClickHouse with generated types
A realistic ClickHouse query usually looks more like analytics SQL than entity loading. This is where a ClickHouse-specific TypeScript layer is more useful than a classic ORM pattern.
Where teams usually get stuck
The questions this page should answer
Does TypeORM support ClickHouse?
TypeORM is not the natural tool for ClickHouse analytics workloads. If you need a TypeScript-first workflow for ClickHouse, hypequery is the more direct fit.
TypeORM alternative for ClickHouse
The better fit is a schema-generated ClickHouse query layer rather than a relational entity ORM. hypequery gives you generated types, fluent queries, and typed APIs around ClickHouse.
ORM for ClickHouse
The practical need is usually type-safe queries and reusable delivery paths, not relational entity mapping. That is the gap hypequery closes for ClickHouse teams.
Use TypeORM with Postgres and ClickHouse together
A common architecture is TypeORM for transactional Postgres or MySQL data and hypequery for ClickHouse analytics. Each tool stays inside the workload shape it was designed for.
Further reading
Go deeper where it actually helps
ClickHouse ORM
The broader page for teams looking for an ORM-like workflow on ClickHouse.
Open guide
Drizzle ORM for ClickHouse
Another dedicated unsupported-ORM intent page aimed at teams coming from Drizzle rather than TypeORM.
Open guide
ClickHouse schema generation
See how live-schema introspection becomes TypeScript types that match actual ClickHouse runtime values.
Open guide
ClickHouse query builder
See the query-builder layer in more detail, including filters, aggregations, joins, and raw SQL escape hatches.
Open guide
Next step
Generate your ClickHouse schema types and try one real analytics query
That is the fastest way to tell whether the TypeORM-style ClickHouse workflow you want is really a generated-schema query-layer problem instead.