GraphQL fácil com Scriba SDK? · VictorPubh

GraphQL é poderoso, mas na prática costuma virar sinônimo de overhead:
schema manual, resolver pra tudo, camada extra só pra mapear banco → API.

A pergunta que me motivou esse projeto foi simples:

E se GraphQL fosse apenas um reflexo direto do banco, sem boilerplate?

Foi daí que nasceu a combinação Scriba + Scriba GraphQL.

O que é o Scriba?

Repositório: https://www.npmjs.com/package/scriba-sdk

O Scriba é um ORM reativo para SQLite com uma ideia radical:

Se parece JavaScript puro, está certo.

Sem:

.save()
.update()
.populate()
migrations manuais
models cheios de decorators

Cada linha do banco vira um objeto vivo.

const user = User[1]   // SELECT automático
user.name = "Alice"   // UPDATE automático

Acesso carrega lazy, atribuição persiste na hora, e relações viram propriedades normais:

user.posts
user.roles

Tudo isso usando Proxy, cache interno e tipagem automática.

Onde o GraphQL entra

Se o ORM já entende:

tabelas
campos
tipos
relações
multi-tenant

…por que repetir tudo isso de novo em resolvers GraphQL?

O Scriba GraphQL gera schemas GraphQL automaticamente a partir do Scriba SDK.

Sem escrever:

schema .graphql
resolver
loader
mapper

Zero-config GraphQL (de verdade)

Configuração mínima:

app.use(
  "/graphql",
  createMultiTenantGraphQL({
    tenantResolver: req => req.headers["x-tenant-id"],
    scribaInstance: scriba
  })
)

Cada request resolve o tenant e já expõe o schema correto.

Header:

x-tenant-id: ipsum

Como o schema fica

Cada tenant vira um namespace:

query {
  ipsum {
    users {
      id
      name
      age
    }
  }
}

Queries vêm automaticamente em versão singular e plural:

query {
  ipsum {
    user(where: { id: { eq: 1 } }) {
      name
    }

    users(
      where: { age: { gte: 18 } }
      limit: 10
      offset: 0
    ) {
      id
      name
      age
    }
  }
}

Filtros e paginação sem resolver manual

Já vem pronto:

eq, ne
gt, gte, lt, lte
in, nin
contains, startsWith, endsWith
limit / offset

Tudo convertido direto para queries do Scriba.

Relações automáticas

Se o Scriba detecta relação, o GraphQL expõe:

query {
  ipsum {
    users {
      name
      invoices {
        total
      }
    }
  }
}

Sem resolver, sem join manual, sem dor.

Schema global (opcional)

Além do modo multi-tenant, existe um schema global para acessar todos os tenants:

app.use(
  "/global",
  createGlobalGraphQL({ scribaInstance: scriba })
)

Útil para:

dashboards
admin
observabilidade
jobs internos

Por que isso existe?

Não é para “substituir” Apollo, Prisma ou GraphQL tradicional.

É para casos onde:

você quer velocidade
quer menos código
o schema muda bastante
GraphQL é camada de leitura
multi-tenant é regra, não exceção

A ideia é simples:

Se o banco já sabe tudo, o GraphQL só precisa refletir isso.

Repositório: https://github.com/johanlabs/scriba-graphql