Modern ORM for typed SQL workflows

JSORM — JSON-first ORM for TypeScript JSORM — ORM JSON-first para TypeScript

Build type-safe queries using a JSON-like API, powered by AST-based SQL generation. Construye consultas type-safe con una API estilo JSON, impulsada por generación SQL basada en AST.

Get Started View Docs

JSON API

Structured reads, writes, and relation mutations. Lecturas, escrituras y mutaciones de relaciones estructuradas.

AST

Predictable SQL generation with explicit shape. Generación SQL predecible con forma explícita.

TypeScript

Inference from model definitions, not duplicated interfaces. Inferencia desde definiciones de modelo, no interfaces duplicadas.

query.ts

const users = await db.get(User, {
  select: {
    name: true,
    role: { name: true },
  },
  where: {
    active: true,
  },
});

What is jsorm Qué es jsorm

A JSON-first ORM with explicit SQL behavior Un ORM JSON-first con comportamiento SQL explícito

jsorm combines typed model definitions, a structured query AST, and adapter-based execution so teams can keep strong TypeScript ergonomics without hiding how SQL is built. jsorm combina definiciones de modelos tipadas, un AST de consultas estructurado y ejecución basada en adaptadores para mantener ergonomía fuerte en TypeScript sin ocultar cómo se construye el SQL.

How jsorm compares Cómo se compara jsorm

Query style Estilo de consulta

jsorm

JSON-like objects backed by a structured AST Objetos tipo JSON respaldados por un AST estructurado

traditional tradicional

Chains, decorators, or handwritten query builders Chains, decoradores o query builders escritos a mano

Typing Tipado

jsorm

Inference from defineModel() as single source of truth Inferencia desde defineModel() como única fuente de verdad

traditional tradicional

Manual interfaces or duplicated types are common Interfaces manuales o tipos duplicados son comunes

SQL visibility Visibilidad de SQL

jsorm

AST and executeSql() keep SQL behavior explicit El AST y executeSql() mantienen el comportamiento SQL explícito

traditional tradicional

Magic layers can hide generated SQL details Capas mágicas pueden ocultar detalles del SQL generado

jsorm is built for teams that want readable JSON-like queries, strong TypeScript inference, and the ability to reason about SQL instead of trusting hidden runtime magic. jsorm está pensado para equipos que quieren consultas legibles estilo JSON, inferencia fuerte en TypeScript y la capacidad de razonar sobre SQL en lugar de confiar en magia oculta de runtime.

It separates model definition, field metadata, query building, adapter execution, and migration runtime so each concern stays clear and extensible. Separa definición de modelos, metadata de campos, construcción de consultas, ejecución de adaptadores y runtime de migraciones para que cada responsabilidad se mantenga clara y extensible.

The result is a workflow that feels higher level than raw SQL, but still honest about the SQL being generated. El resultado es un flujo más alto nivel que SQL raw, pero honesto sobre el SQL que se está generando.

Core features Características core

Designed for modern TypeScript backends Diseñado para backends modernos en TypeScript

Every feature is built around a single source of truth: your model definition and the structured AST derived from it. Cada característica está construida alrededor de una única fuente de verdad: tu definición de modelo y el AST estructurado derivado de ella.

JSON-first queries Consultas JSON-first

Describe reads and writes with plain objects instead of opaque chain builders. Describe lecturas y escrituras con objetos simples en lugar de builders opacos.

await db.get(User, {
  select: { id: true, role: { name: true } },
  where: { active: true },
});

Typed models and inference Modelos tipados e inferencia

Define schemas once and infer records plus input types directly from models. Define esquemas una vez e infiere registros y tipos de entrada directamente desde los modelos.

const User = defineModel('users', {
  id: t.number().primary(),
  name: t.string(),
  role: t.belongsTo(Role),
});

Explicit relations Relaciones explícitas

Use belongsTo, hasOne, hasMany, and manyToMany with predictable SQL behavior. Usa belongsTo, hasOne, hasMany y manyToMany con comportamiento SQL predecible.

const Post = defineModel('posts', {
  author: t.belongsTo(User),
  tags: t.manyToMany(Tag),
});

Multi-database support Soporte multi-base de datos

Orchestrate PostgreSQL, MySQL, and SQLite connections from one typed entry point. Orquesta conexiones PostgreSQL, MySQL y SQLite desde un punto de entrada tipado.

const db = connectionDB({
  databases: {
    main: pgAdapter({ connectionString }),
    cache: sqliteAdapter({ file: ':memory:' }),
  },
});

Raw SQL when needed SQL raw cuando lo necesites

Keep full SQL power available through executeSql() without abandoning the JSON API. Mantén toda la potencia de SQL disponible con executeSql() sin abandonar la API JSON.

await db.executeSql(
  'SELECT COUNT(*) AS count FROM users WHERE active = ?',
  [true],
);

Optional migrations Migraciones opcionales

Connect to an existing database immediately or opt into migration runtime and CLI. Conéctate a una base existente de inmediato u opta por runtime y CLI de migraciones.

const source = defineConnectionSource({
  adapter: pgAdapter({ connectionString }),
});

Code examples Ejemplos de código

Readable abstractions, predictable output Abstracciones legibles, salida predecible

Use jsorm for schemas, nested reads, relation mutations, and multi-database orchestration without losing control of what reaches the database. Usa jsorm para esquemas, lecturas anidadas, mutaciones de relaciones y orquestación multi-base de datos sin perder control de lo que llega a la base.

Model definition Definición de modelo

example.ts

const Role = defineModel('roles', {
  id: t.number().primary(),
  name: t.string().unique(),
});

const User = defineModel('users', {
  id: t.number().primary(),
  name: t.string(),
  role: t.belongsTo(Role),
});

Insert with relations Insert con relaciones

example.ts

await db.insert(User, {
  name: 'Alice',
  role: { connect: 1 },
  profile: {
    create: { bio: 'Builder' },
  },
});

Select nested data Select con datos anidados

example.ts

const rows = await db.get(User, {
  select: {
    id: true,
    name: true,
    role: { name: true },
  },
  where: {
    role: {
      name: { eq: 'admin' },
    },
  },
});

Why jsorm Por qué jsorm

Built for engineers who want clarity, not hidden magic Construido para ingenieros que quieren claridad, no magia oculta

The architecture favors explicit modeling, adapter boundaries, and extensibility over clever shortcuts. La arquitectura prioriza modelado explícito, límites de adaptadores y extensibilidad sobre atajos ingeniosos.

Expressive API with explicit structure

No hidden magic between JSON, AST, and SQL

Full SQL power stays available when abstraction is not enough

Modular packages for adapters and future ecosystem growth

Ecosystem Ecosistema

Modular packages for a flexible ORM stack Paquetes modulares para un stack ORM flexible

Install only what you need. Keep the core package lightweight while adapters wrap official drivers. Instala solo lo que necesitas. Mantén el paquete core liviano mientras los adaptadores envuelven drivers oficiales.

pnpm add jsorm jsorm-pg jsorm-sqlite jsorm-mysql

jsorm

Core ORM, model system, query AST, migrations, CLI, and adapter contracts. ORM core, sistema de modelos, AST de consultas, migraciones, CLI y contratos de adaptadores.

jsorm-pg

PostgreSQL adapter built around official pg driver patterns. Adaptador PostgreSQL construido sobre los patrones del driver oficial pg.

jsorm-sqlite

SQLite adapter for lightweight apps, local tools, and tests. Adaptador SQLite para apps livianas, herramientas locales y pruebas.

jsorm-mysql

MySQL adapter for production services and analytics workloads. Adaptador MySQL para servicios productivos y cargas analíticas.