Download remult - download de código fonte remult

Remulto

Crud de pilha completa, simplificada, com entidades datilografadas SSOT

Tutoriais | QuickStart | Exemplo de aplicativos

O que é remúmero?

O Remult usa as entidades TypeScript como uma única fonte de verdade para: ✅ CRUD + API em tempo real, ✅ Cliente de API de tipo-tipo de front-end e ✅ ✅ ✅ back-end ORM.

⚡ CRUD de plataforma zero + API em tempo real com paginação, classificação e filtragem
? FullStack Type-segurança para consultas de API, mutações e RPC, sem geração de código
A validação de entrada, definida uma vez , é executada no back -end e no front -end para o melhor UX
Autorização de API baseada em código de granulação fina
? Incrementalmente adotável

O REULT suporta todos os principais bancos de dados , incluindo: PostgreSQL, MySQL, SQLite, MongoDB, MSSQL e Oracle.

O Remult é a estrutura de front -end e back -end AGNOSTIC e vem com adaptadores para Express, Fastify, Next.js, Nuxt, Sveltekit, Solidstart, Nest, Koa, Hapi e Hono.

Quer experimentar o remunto em primeira mão? Experimente nosso tutorial on -line interativo.

O Remult promove uma sintaxe de consulta consistente para o código de front -end e back -end :

 // Frontend - GET: /api/products?_limit=10&unitPrice.gt=5,_sort=name
// Backend  - 'select name, unitPrice from products where unitPrice > 5 order by name limit 10'
await repo ( Product ) . find ( {
  limit : 10 ,
  orderBy : {
    name : 'asc' ,
  } ,
  where : {
    unitPrice : { $gt : 5 } ,
  } ,
} )

// Frontend - PUT: '/api/products/product7' (body: { "unitPrice" : 7 })
// Backend  - 'update products set unitPrice = 7 where id = product7'
await repo ( Product ) . update ( 'product7' , { unitPrice : 7 } )

Uso

Definir esquema no código

 // shared/product.ts

import { Entity , Fields } from 'remult'

@ Entity ( 'products' , {
  allowApiCrud : true ,
} )
export class Product {
  @ Fields . cuid ( )
  id = ''

  @ Fields . string ( )
  name = ''

  @ Fields . number ( )
  unitPrice = 0
}

Não gosta de decoradores? Temos apoio total para trabalhar sem decoradores

Adicione a API de back -end com uma única linha de código

Exemplo:

 // backend/index.ts

import express from 'express'
import { remultExpress } from 'remult/remult-express' // adapters for: Fastify,Next.js, Nuxt, SvelteKit, SolidStart, Nest, more...
import { createPostgresDataProvider } from 'remult/postgres' // supported: PostgreSQL, MySQL, SQLite, MongoDB, MSSQL and Oracle
import { Product } from '../shared/product'

const app = express ( )

app . use (
  remultExpress ( {
    entities : [ Product ] ,
    dataProvider : createPostgresDataProvider ( {
      connectionString : 'postgres://user:password@host:5432/database"' ,
    } ) ,
  } ) ,
)

app . listen ( )

O Remult adiciona manipuladores de rota para uma API de REST totalmente funcional e terminais em tempo real, opcionalmente, incluindo uma especificação de API aberta e um endpoint grafql

Buscar dados com código de front-end, seguro

 const [ products , setProducts ] = useState < Product [ ] > ( [ ] )

useEffect ( ( ) => {
  repo ( Product )
    . find ( {
      limit : 10 ,
      orderBy : {
        name : 'asc' ,
      } ,
      where : {
        unitPrice : { $gt : 5 } ,
      } ,
    } )
    . then ( setProducts )
} , [ ] )

Consultas ao vivo em tempo real

 useEffect ( ( ) => {
  return repo ( Product )
    . liveQuery ( {
      limit : 10 ,
      orderBy : {
        name : 'asc' ,
      } ,
      where : {
        unitPrice : { $gt : 5 } ,
      } ,
    } )
    . subscribe ( ( info ) => {
      setProducts ( info . applyChanges )
    } )
} , [ ] )

☑️ Validação e restrições de dados - definidas uma vez

 import { Entity , Fields , Validators } from 'remult'

@ Entity ( 'products' , {
  allowApiCrud : true ,
} )
export class Product {
  @ Fields . cuid ( )
  id = ''

  @ Fields . string ( {
    validate : Validators . required ,
  } )
  name = ''

  @ Fields . number < Product > ( {
    validate : ( product ) => product . unitPrice > 0 || 'must be greater than 0' ,
  } )
  unitPrice = 0
}

Forçado no frontend:

 try {
  await repo ( Product ) . insert ( { name : '' , unitPrice : - 1 } )
} catch ( e : any ) {
  console . error ( e )
  /* Detailed error object ->
{
  "modelState": {
    "name": "Should not be empty",
    "unitPrice": "must be greater than 0"
  },
  "message": "Name: Should not be empty"
}
*/
}

Forçado no back -end:

 // POST '/api/products' BODY: { "name":"", "unitPrice":-1 }
// Response: status 400, body:
{
  "modelState" : {
    "name" : "Should not be empty" ,
    "unitPrice" : "must be greater than 0"
  } ,
  "message" : "Name: Should not be empty"
}

Prenda a API com autorização de granulação fina

@ Entity < Article > ( 'Articles' , {
  allowApiRead : true ,
  allowApiInsert : Allow . authenticated ,
  allowApiUpdate : ( article ) => article . author == remult . user . id ,
  apiPrefilter : ( ) => {
    if ( remult . isAllowed ( 'admin' ) ) return { }
    return {
      author : remult . user . id ,
    }
  } ,
} )
export class Article {
  @ Fields . string ( { allowApiUpdate : false } )
  slug = ''

  @ Fields . string ( { allowApiUpdate : false } )
  authorId = remult . user ! . id

  @ Fields . string ( )
  content = ''
}

Relações

 await repo ( Categories ) . find ( {
  orderBy : {
    name : 'asc ' ,
  } ,
  include : {
    products : {
      where : {
        unitPrice : { $gt : 5 } ,
      } ,
    } ,
  } ,
} )

// Entity Definitions
export class Product {
  //...
  @ Relations . toOne ( Category )
  category ?: Category
}
export class Category {
  //...
  @ Relations . toMany < Category , Product > ( ( ) => Product , `category` )
  products ?: Product [ ]
}

UI de administrador automática

E quanto ao complexo Crud?

Embora o simples Crud não exija nenhuma codificação de back -end, usar o remuneiro significa ter a capacidade de lidar com qualquer cenário complexo, controlando o back -end de várias maneiras:

Campos computados de back -end (somente leitura) - de expressões simples a pesquisas de dados complexas ou até acesso direto a dB (SQL)
Efeitos colaterais personalizados com ganchos de ciclo de vida da entidade (antes/depois de salvar/excluir)
Back -end apenas campos atualizáveis (por exemplo, “Última atualização em”)
Relações
Roll-your-your-type-stendpoints com métodos de back-end
Roll-Your-Your-Your-Your-Level Nível Gondpoints (Express, Fastify, Koa, outros…)

Instalação

O pacote Remult é o mesmo para o pacote de front -end e o back -end. Instale-o uma vez para um projeto de monólito ou per-repetição em um monorepo.

npm i remult

Tutoriais

A melhor maneira de aprender o Remult é seguindo um tutorial de um aplicativo da Web simples com um back -end do Node.js Express.

Tutorial com React
Tutorial com angular
Tutorial com Vue
Tutorial com Next.js
Tutorial com Sveltekit
Tutorial com Solidstart

Demonstração

Miniatura de vídeo

Assista a demonstração do código no YouTube aqui (14 minutos)

Documentação

A documentação abrange os principais recursos do remunto. No entanto, ainda é um trabalho em andamento.

Exemplo de aplicativos

Exemplo FullStack TODOMVC com React e Express. (Código -fonte | Código e caixa)
Demonstração de CRM com um banco de dados React + MUI Front-end e Postgres.

Status

O Remult está pronto para produção e, de fato, usado em aplicativos de produção desde 2018. No entanto, estamos mantendo a versão principal em zero para que possamos usar o feedback da comunidade para finalizar a API V1.

Motivação

O desenvolvimento da Web de palha total é (ainda) muito complicada. O simples Crud, um requisito comum de qualquer aplicativo comercial, deve ser simples de construir, manter e estender quando surgir a necessidade.

O remédio abstrante fora o código repetitivo, o caldeiro, propenso a erros e mal projetado, por um lado, e permite a flexibilidade e o controle total, por outro. O REULT ajuda a criar aplicativos FullStack usando apenas o código TypeScript que você pode seguir facilmente e refatorar com segurança e se encaixa perfeitamente em qualquer projeto existente ou novo, sendo minimalista e completamente poucopinado em relação à escolha do desenvolvedor de outras estruturas e ferramentas.

Outras estruturas tendem a cair em muita abstração (sem código, baixo código, BAAs) ou abstração parcial (estruturas MVC, grafql, orms, geradores de API, geradores de código) e tendem a ser opinativos sobre a cadeia de ferramentas de desenvolvimento, o ambiente de implantação, a configuração/convenções ou DSL. Remulto tentativa de encontrar um equilíbrio melhor.