Tutorial Meteor: Construindo Aplicações Web em Tempo Real com Meteor
Publicados: 2022-03-11Meteor é um framework JavaScript full-stack para aplicações web e móveis. Ele existe desde 2011 e ganhou uma forte reputação entre os desenvolvedores do Meteor por ser uma solução ideal e fácil de usar para prototipagem rápida. No entanto, ultimamente os desenvolvedores perceberam que o Meteor não é mais apenas para prototipagem: está pronto para ser usado para desenvolvimento comercial. Com o arsenal de pacotes que fornece, a base sólida do mongoDB/node.js em que se baseia e a flexibilidade de codificação que oferece; O Meteor facilita a criação de aplicativos Web robustos e seguros em tempo real, lidando com tudo, desde o aplicativo do navegador até o servidor ou banco de dados.
Este tutorial do Meteor irá guiá-lo através da criação de uma aplicação web básica no Meteor - um catálogo simples que permite aos usuários fazer login e gerenciar uma lista de livros.
Por que usar Meteoro? A resposta curta é “porque o Meteor é divertido”. Isso torna o desenvolvimento de aplicativos da Web simples. É fácil de aprender e permite que você se concentre mais na funcionalidade do seu aplicativo do que no básico de sincronização de dados e páginas de serviço.
Ele também tem muitos comportamentos convenientemente integrados. O Meteor executa automaticamente atualizações ao vivo, então as alterações de dados aparecem imediatamente na janela do seu navegador, e até mesmo as alterações de código no próprio aplicativo são enviadas para todos os navegadores e dispositivos em “tempo real”. O Meteor possui compensação de latência embutida, é fácil de implantar e possui “pacotes” fáceis de instalar que lidam com todos os tipos de funcionalidades.
Mesmo sendo uma estrutura relativamente nova, muitas startups já estão criando aplicativos Meteor, incluindo serviços de escala relativamente grande, como Respondly e Telescope.
Instalação e andaimes de meteoros
A instalação do Meteor em sistemas *nix é uma linha simples:
curl https://install.meteor.com/ | shEmbora ainda não haja suporte oficial, sua visualização para o Windows está indo muito bem. Os rumores são de que o suporte do Windows será lançado com a versão 1.1, prevista para abril ou maio de 2015. Como você pode esperar de uma estrutura inteligente como o Meteor, inicializar um aplicativo requer que uma única linha de comando seja invocada:
meteor create book-listIsso criará um diretório chamado “book-list” e o preencherá com algum código padrão e dependente. Para executar o aplicativo, entre no diretório recém-criado e execute:
meteor Abra http://localhost:3000 em seu navegador da Web e você verá o seguinte:
Você também pode conferir a “versão 0” do nosso aplicativo no MeteorPad, um site parecido com JSFiddle para Meteor: Book List: Default App
O Meteor armazena suas visualizações em arquivos HTML. Se abrirmos “book-list.html”, veremos:
<head> <title>book-list</title> </head> <body> <h1>Welcome to Meteor!</h1> {{> hello}} </body> <template name="hello"> <button>Click Me</button> <p>You've pressed the button {{counter}} times.</p> </template>O Meteor usa o “Blaze”, um mecanismo de modelagem, para renderizar as respostas desses arquivos HTML. As chaves duplas devem ser familiares para qualquer um que tenha usado Handlebars.js (ou outros mecanismos de modelagem semelhantes), e eles servem a uma função semelhante aqui. Blaze examina as expressões dentro de cada par de chaves duplas e substitui cada uma pelo valor que essas expressões produzem.
Este programa de exemplo simples tem apenas duas expressões entre colchetes:
O primeiro, “{{> hello}}”, diz ao Blaze para incluir um template chamado “hello”. Esse modelo é definido na parte inferior do arquivo, na seção <template name="hello">.
O segundo, “{{counter}}”, é um pouco mais complicado. Para ver de onde vem esse valor “counter”, precisamos abrir “book-list.js”:
if (Meteor.isClient) { // counter starts at 0 Session.setDefault('counter', 0); Template.hello.helpers({ counter: function () { return Session.get('counter'); } }); Template.hello.events({ 'click button': function () { // increment the counter when button is clicked Session.set('counter', Session.get('counter') + 1); } }); } if (Meteor.isServer) { Meteor.startup(function () { // code to run on server at startup }); }Algumas coisas requerem explicação aqui. Primeiro, a divisão em “if (Meteor.isClient)” e “if (Meteor.isServer)”. Lembre-se de que meteor é uma estrutura de pilha completa, portanto, o código que você escreve é executado no servidor e no cliente. Essas condicionais nos permitem limitar isso: o primeiro bloco é executado apenas no cliente e o segundo é executado apenas no servidor.
Segundo, há a chamada “Session.setDefault” - isso inicializa uma variável de sessão chamada “counter” no navegador. As variáveis de sessão agem um pouco como globais no Meteor (para o bem e para o mal). No entanto, essa variável de sessão não está aparecendo diretamente em “{{counter}}”. Em vez disso, essa expressão "contador" é um "auxiliar", definido na seção "Template.hello.helpers". Este auxiliar simplesmente pega o valor da variável de sessão e o retorna.
Observe que o auxiliar é “reativo”. Isso significa que sempre que a variável de sessão muda, o Meteor automaticamente executa novamente essa função auxiliar que está fazendo referência a ela, e o Blaze atualiza automaticamente o navegador com o novo conteúdo.
O código do cliente também monitora eventos, via “Template.hello.events”. Identificamos o evento por tipo de evento e seletor (neste caso, “clique no botão”) e, em seguida, informamos ao Meteor o que esse evento deve fazer. Nesse caso, a variável de sessão é incrementada, o que executa novamente a função auxiliar e, por sua vez, renderiza novamente o conteúdo.
Exibindo dados estáticos
Tudo isso é muito bom, mas não é o aplicativo Meteor que queremos para este tutorial.
Vamos começar a ajustar este aplicativo - exibiremos uma lista estática e codificada de livros. Por enquanto, vamos armazenar a lista de livros em uma variável de sessão. No código “isClient”, usaremos “Template.hello.rendered” para definir a variável de sessão assim que o modelo bookList for renderizado:
Template.hello.rendered = function() { Session.setDefault('books', [ {title: "To Kill a Mockingbird", author: "Harper Lee"}, {title: "1984", author: "George Orwell"}, {title: "The Lord of the Rings", author: "JRR Tolkien"}, {title: "The Catcher in the Rye", author: "JD Salinger"}, {title: "The Great Gatsby", author: "F. Scott Fitzgerald"} ]); };Em seguida, retornamos essa variável de sessão com um novo auxiliar no modelo “hello”:
Template.hello.helpers({ books: function () { return Session.get('books'); } });E exiba-o na tela por meio de interpolação de variável no modelo “hello”:
<template name="hello"> <h3>Here are your books:</h3> {{ books }} </template>Você pode conferir este código em ação no Meteorpad: Book-List: Show Session Variable
A primeira coisa a notar é que o servidor Meteor detectou automaticamente as alterações em nossa base de código, empurrou o novo código para os clientes e solicitou que o cliente recarregasse. Mesmo depois de implantarmos um aplicativo, podemos implantar alterações e atualizar automaticamente nossos clientes por meio de push de código ativo.
Até agora, isso é o que temos:
Ops, estamos exibindo os dados errados. Blaze ganha pontos por precisão aqui (por que sim, é uma matriz de objetos), mas teremos que ser um pouco mais espertos se quisermos exibir nossa lista de livros de uma maneira útil. Felizmente, o Blaze torna muito fácil trabalhar com arrays de dados usando a diretiva “#each”:
<h3>Here are your books:</h3> <UL> {{#each books}} <LI><i>{{title}}</i> by {{author}}</LI> {{/each}} </UL>No Blaze, “#each” funciona um pouco como a diretiva “ng-repeat” do Angular - ele itera pela estrutura do array, definindo o contexto atual para o objeto atual no array e exibindo repetidamente o HTML dentro do “{{#each …}}”. Esta é a nossa lista de livros agora:
No MeteorPad: Mostrar a variável de sessão corretamente
Alguma limpeza
Antes de prosseguir, vamos limpar um pouco nosso código.
O Meteor permite uma tremenda margem de manobra na forma como você organiza sua base de código. Como você verá, existem apenas algumas regras rígidas e rápidas: onde quer que você coloque seu HTML e JavaScript, o Meteor o encontrará. Essa flexibilidade é boa, mas significa que cabe mais a você organizar seu código de uma maneira que faça sentido, para que você não fique preso mantendo uma bagunça gigantesca e desordenada.
Primeiro, vamos renomear este modelo “hello” para algo significativo, como “bookList”, e substituir o HTML padrão por este:
<head> <title>book-list</title> </head> <body> {{> bookList}} </body> <template name="bookList"> <h3>Here are some books:</h3> <UL> {{#each books}} <LI><i>{{title}}</i> by {{author}}</LI> {{/each}} </UL> </template>Segundo, vamos dividir as partes “cliente” e “servidor” em arquivos separados. Em nosso diretório de aplicativos, vamos configurar um subdiretório “cliente” e um subdiretório “servidor” - Meteor saberá automaticamente para executar os arquivos “/client/” no cliente e executar os arquivos “/server/” no servidor. É uma boa convenção colocar código de modelo em um arquivo JavaScript com o nome do modelo, então vamos colocar nosso código de cliente em “client/bookList.js”. Podemos colocar nosso código de inicialização do servidor atualmente vazio em “server/startup.js”. Finalmente, vamos remover o “ ” código do modelo para “client/bookList.html”.
Observe que, mesmo depois de toda essa troca, o Meteor ainda encontrará automaticamente todos os nossos arquivos HTML e JavaScript. Enquanto um arquivo estiver em algum lugar em “/client/”, o Meteor saberá executá-lo no cliente. Enquanto um arquivo estiver em algum lugar em “/server/”, o meteor saberá executá-lo no servidor. Novamente, cabe ao desenvolvedor manter as coisas organizadas.
Então agora nosso código deve ficar assim:
book-list.html:
<head> <title>book-list</title> </head> <body> {{> bookList}} </body>client/bookList.html:
<template name="bookList"> <h3>Here are some books:</h3> <UL> {{#each books}} <LI><i>{{title}}</i> by {{author}}</LI> {{/each}} </UL> </template>client/bookList.js:
Template.bookList.rendered = function() { Session.setDefault('books', [ {title: "To Kill a Mockingbird", author: "Harper Lee"}, {title: "1984", author: "George Orwell"}, {title: "The Lord of the Rings", author: "JRR Tolkien"}, {title: "The Catcher in the Rye", author: "JD Salinger"}, {title: "The Great Gatsby", author: "F. Scott Fitzgerald"} ]); }; Template.bookList.helpers({ books: function () { return Session.get('books'); } });server/startup.js:
Meteor.startup(function () { // code to run on server at startup }); ~~~ Check it out on MeteorPad: [Initial Code Cleanup](http://meteorpad.com/pad/MwvMcsBAzfbWwEXp3/Book-List:%20Initial%20Code%20Cleanup) Verify that everything's running correctly by checking the browser window and then we're good to move on to the next step. ## Using the Database in Meteor The Meteor server runs on top of a MongoDB database. In this section of our tutorial, we will move the static list of books out of the session variable and into that database. First, delete the Template.bookList.rendered code, so that we're no longer putting stuff into that session variable. Next, we should add that list of books to the database as fixture data when the server initializes. As you'd expect for MongoDB, Meteor stores data in "collections". So, we'll create a new collection for our books. To keep things simple we will name it "books". It turns out that both the client and the server will want to know about this collection, so we'll put this code in a new subfolder: "/lib/". Meteor knows automatically that files in "/lib/" run on the client and the server. We'll create a file called "lib/collections/books.js", and give it just one line of code: ~~~ js Books = new Meteor.Collection("books");Dentro da janela do navegador apontada para http://localhost:3000, acesse o console do desenvolvedor e verifique o valor de “Books”. Agora deve ser uma coleção Mongo! Tente executar “Books.find().fetch()”, e você obterá um array vazio – o que faz sentido, já que ainda não adicionamos nenhum livro a ele. Podemos tentar adicionar itens a ele no console:
Books.insert({title: "To Kill a Mockingbird", author: "Harper Lee"})Adicionar coisas no console é bastante tedioso. Em vez disso, vamos configurar as coisas para que, quando o servidor for inicializado, insiramos automaticamente os dados do fixture no banco de dados. Então, vamos voltar para “server/startup.js” e adicionar isto:
Meteor.startup(function () { if (!Books.findOne()) { Books.insert({title: "To Kill a Mockingbird", author: "Harper Lee"}); Books.insert({title: "1984", author: "George Orwell"}); Books.insert({title: "The Lord of the Rings", author: "JRR Tolkien"}); Books.insert({title: "The Catcher in the Rye", author: "JD Salinger"}); Books.insert({title: "The Great Gatsby", author: "F. Scott Fitzgerald"}); } });Agora, quando o servidor iniciar, se não houver dados presentes, adicionaremos os dados do fixture. Podemos verificar isso voltando ao nosso terminal, parando o servidor meteoro e executando este comando:
meteor resetNota: você raramente precisará deste comando, porque ele redefine - ou seja, limpa - o banco de dados que o Meteor está usando. Se o seu aplicativo Meteor tiver dados de usuário no banco de dados, você não deve executar este comando. Mas neste caso, vamos apenas limpar os dados de teste que temos.
Agora vamos iniciar o servidor novamente:
meteorNa inicialização, o Meteor executará a rotina de inicialização, verificará se o banco de dados está vazio e adicionará os dados do equipamento. Neste ponto, se formos ao console e digitarmos “Books.find().fetch()”, obteremos os cinco livros que tínhamos antes.
Tudo o que resta para esta etapa é exibir os livros na tela. Felizmente, isso é tão simples quanto substituir “return Session.get('books');” com o seguinte no auxiliar de “livros”:
return Books.find();E estamos de volta aos negócios! O aplicativo agora está exibindo dados de um cursor de banco de dados, em vez de da variável de sessão.
Confira no MeteorPad: Movendo-se para o banco de dados
Preocupações com segurança
Vou começar dizendo: “não faça isso”.
O que você acha que aconteceria se alguém iniciasse este aplicativo em seu navegador, acessasse o console e digitasse “Books.remove({})”?
A resposta é: eles acabariam com a coleção.
Então, esse é um grande problema de segurança - nossos usuários têm muito acesso ao nosso banco de dados. Qualquer cliente pode acessar todo o banco de dados. Além disso, qualquer cliente pode fazer qualquer alteração em todo o banco de dados, incluindo a eliminação de dados “.remove({})”.
Isso não é bom, então vamos corrigi-lo.
O Meteor usa os chamados “pacotes” para adicionar funcionalidades. O que os módulos são para o Node.js e as gems são para o Ruby, os pacotes são uma funcionalidade agregada para o Meteor. Existem pacotes para todos os tipos de coisas. Para navegar pelo que está disponível, confira atmosfera.js.
O aplicativo meteoro padrão que criamos com “meteor create” inclui dois pacotes chamados “autopublish” e “insecure”. O primeiro pacote faz com que os clientes tenham acesso automático a todo o banco de dados, e o segundo faz com que os usuários possam realizar qualquer ação nesse banco de dados.
Vamos removê-los. Podemos fazer isso executando o seguinte no diretório do aplicativo:
meteor remove autopublish insecureQuando isso for feito, você verá os dados da lista de livros desaparecerem da tela (já que você não tem mais acesso a eles), e se você tentar uma chamada “Books.insert”, você receberá o erro: “insert failed : Acesso negado". No MeteorPad: exagero de segurança
Se você não pegar mais nada deste tutorial do Meteor, lembre-se disso: quando você estiver implantando um aplicativo Meteor, certifique-se de remover os pacotes autopublish e insecure. O Meteor tem muitas precauções de segurança boas, mas todas elas são em vão se você deixar esses dois pacotes instalados.
Então, por que o Meteor inclui automaticamente esses pacotes, se eles são tão perigosos para a segurança? A razão é que, especialmente para iniciantes, esses dois pacotes facilitam o início - você pode facilmente depurar e ajustar o banco de dados a partir do console de um navegador. Mas é uma boa prática abandonar a publicação automática e a insegurança o mais rápido possível.
Publicar e assinar
Então corrigimos essa falha de segurança, mas introduzimos dois problemas. Primeiro, agora não temos acesso ao banco de dados. Segundo, não temos como interagir com o banco de dados.
Vamos resolver o primeiro problema aqui. O Meteor fornece acesso seguro a um banco de dados fazendo com que o servidor “publique” um subconjunto do banco de dados e fazendo com que o cliente “assine” essa publicação.
Primeiro, vamos criar “/server/publications.js”:
Meteor.publish('books', function() { return Books.find({}); });E vamos criar “/client/subscriptions.js”:
Meteor.subscribe('books');Confira no MeteorPad: Publique e Assine
O servidor “publica” um cursor que tem acesso a todos os dados, e o cliente “assina” na outra ponta. O cliente usa essa assinatura para preencher uma cópia espelhada do banco de dados com todos os dados do cursor. Quando acessamos “Books.find().fetch()”, vemos todos os cinco objetos e os vemos exibidos na tela como antes.
A diferença agora é que é muito fácil limitar o que os clientes podem acessar. Tente mudar a publicação “find()” para um subconjunto dos dados:
Meteor.publish('books', function() { return Books.find({}, {limit:3}); });Agora o cliente só vê três dos cinco livros, e não há como chegar ao resto. Isso não é apenas um grande benefício para a segurança (não consigo ver as contas bancárias de todos), mas você pode usá-lo para parcelar dados e evitar sobrecarregar um cliente.
Adicionando novos livros
Vimos como dar aos clientes acesso de leitura ao banco de dados de forma limitada e segura. Agora, vamos ver o segundo problema: como deixar os usuários alterarem o banco de dados sem permitir que eles façam o que quiserem? Livrar-se do pacote inseguro fez com que os clientes não tivessem acesso - vamos tentar permitir a adição de livros novamente. No meteor, fazemos isso adicionando um “método” ao servidor. Vamos adicionar um método, um que adiciona um novo livro, a “/lib/collections/books.js”:
Meteor.methods({ addBook: function(bookData) { var bookID = Books.insert(bookData); return bookID; } });Como você pode ver, isso pega “bookData” – neste caso, é um objeto com os campos “title” e “author” – e o adiciona ao banco de dados. Depois que seu cliente for recarregado, podemos chamar esse método do cliente. Você pode ir ao console e digitar algo assim:
Meteor.call('addBook', {title: "A Tale of Two Cities", author: "Charles Dickens"})E pronto! Você recebe outro livro na lista de livros. Usar o console é intoleravelmente desajeitado, então vamos em frente e adicionar um formulário simples ao final do modelo “bookList” que nos permitirá adicionar novos livros:
<form class="add-book"> Title:<br> <input type="text" name="title"> <br> Author:<br> <input type="text" name="author"> <input type="submit" value="Add Book"> </form>E podemos conectar isso ao JavaScript usando um caso de evento, como fizemos no aplicativo de teste original:
Template.bookList.events({ "submit .add-book": function(event) { event.preventDefault(); // this prevents built-in form submission Meteor.call('addBook', {title: event.target.title.value, author: event.target.author.value}) } });Você pode ver isso em ação no MeteorPad: Métodos
Quando tínhamos a publicação insegura e automática, os clientes podiam acessar e alterar todo o banco de dados. Agora com o fim do inseguro e da publicação automática, mas com publicações, assinaturas e métodos, os clientes podem acessar o banco de dados e interagir com ele de maneira controlada.
Em uma nota lateral: você também pode resolver problemas de segurança no Meteor usando “regras de permissão e negação”. Você pode descobrir mais sobre essas e algumas razões pelas quais prefiro a abordagem acima emdiscovermeteor.com.
Autenticação de usuário
Pode parecer que acabamos de voltar para onde começamos, mas há uma diferença importante: é muito fácil para nós agora limitar o acesso ao banco de dados. Para ver como isso funciona, vamos tentar adicionar usuários a este aplicativo. Adicionaremos um sistema de login ao nosso aplicativo e, em vez de fazer com que todos os clientes trabalhem com uma lista de livros de todo o sistema, faremos com que cada usuário só possa adicionar ou ler sua própria lista de livros.
Vá para o diretório do aplicativo e instale dois pacotes:
meteor add accounts-ui accounts-passwordLá. Você acabou de adicionar um sistema de login ao aplicativo. Agora só precisamos adicionar a UI de login ao book-list.html. Coloque esta única linha na parte superior do corpo:
{{> loginButtons}}Você deve ver um prompt de login na parte superior da tela:
Observe que, se você clicar no link de login, ele solicitará um endereço de e-mail e uma senha. Podemos mudar isso para um sistema de login de nome de usuário/senha simples criando “/client/config.js” com o seguinte:
Accounts.ui.config({ passwordSignupFields: "USERNAME_ONLY" });Neste ponto, você pode digitar “Meteor.userId()” no console e ele retornará “null”. Você pode tentar clicar no link para criar uma conta. Chamar “Meteor.userId()” agora deve retornar uma string de ID. O servidor tem acesso a esta mesma informação (como “this.userId”), então é trivial fazer o método “add books” forçar o usuário a estar logado e incluir um campo userID:
Meteor.methods({ addBook: function(bookData) { if (this.userId) { bookData.userID = this.userId; var bookID = Books.insert(bookData); return bookID; } } });Tudo o que resta agora é limitar o cliente, mostrando apenas os livros que este usuário adicionou. Usamos a capacidade da publicação para restringir o que o cliente tem acesso:
Meteor.publish('books', function() { return Books.find({userID: this.userId}); });Agora, a publicação só encontra livros desse usuário em particular. Podemos até acessar o userId das expressões Blaze como “{{currentUser}}”; e podemos usar isso, com uma diretiva “{{#if}}” (que faz exatamente o que você acha que faz), para mostrar dados apenas quando o usuário estiver logado:
<template name="bookList"> {{#if currentUser}} <h3>Here are your books:</h3> <UL> {{#each books}} <LI><i>{{title}}</i> by {{author}}</LI> {{/each}} </UL> <form class="add-book"> Title:<br> <input type="text" name="title"> <br> Author:<br> <input type="text" name="author"> <input type="submit" value="Add Book"> </form> {{else}} <h3>Please log in to see your books</h3> {{/if}} </template>Confira o resultado final no MeteorPad: Usuários
Desdobramento, desenvolvimento
Agora podemos implantar este aplicativo Meteor na Internet. Fazemos isso indo para o diretório do aplicativo em um terminal e executando:
meteor deploy <your app's name>.meteor.comCertifique-se de substituir “<nome do seu aplicativo>” por um nome real e curto para a instância do aplicativo. A execução deste comando solicitará que você configure uma conta com o Meteor e, em seguida, colocará seu novo aplicativo nos servidores de teste do Meteor para que você possa testá-lo na Internet.
Para uma demonstração rápida, esta solução meteor.com é tudo que você precisa. A equipe do Meteor não anunciou nenhum limite explícito de armazenamento ou largura de banda em seus servidores. A única limitação notável é que, se seu aplicativo não for usado por um longo tempo, o site levará alguns segundos para ser ativado para o próximo usuário.
Dito isto, meteor.com não se destina a uso comercial. Mas quando você vai para a produção, existem empresas de plataforma como serviço, como Modulus e Digital Ocean, que facilitam a implantação de aplicativos Meteor. Se você quiser implantar um aplicativo meteoro em seu próprio servidor, o “meteor up” também simplifica esse processo.
Próximos passos
Parabéns! Em sua busca para aprender o Meteor, você criou e implantou um aplicativo Web muito simples do Meteor em tempo real. Obviamente, este é apenas um pequeno primeiro passo em todo um universo de recursos e funcionalidades. Se você gostou do que viu até agora, recomendo fortemente Your First Meteor Application, de David Turnbull, que orienta os leitores na criação de um aplicativo mais complicado, com mais informações sobre recursos de meteoros ao longo do caminho. Está disponível como um livro Kindle por um pequeno preço e como um PDF gratuito no site da Turnbull.
Você também vai querer explorar os pacotes que estão disponíveis para o Meteor. Nove em cada dez vezes, a resposta para “como faço <x> no Meteor?” é “há um pacote para isso”. “Como adiciono roteamento ao meu aplicativo?” Você usa o Iron Router. “Como forneço uma API RESTful?” Você usa RESTivus. “Como incluo o teste de unidade?” Você usa Velocidade. “Como adiciono validações de esquema?” Você usa Collection2. Você pode facilmente se perder no Atmosphere.js olhando todos os pacotes disponíveis.
Por que não usar meteoro?
Como você pode ver neste tutorial, o Meteor é simples e divertido para escrever aplicativos, mas eu seria negligente se não mencionasse as desvantagens.
Meteor ainda é relativamente imaturo. Ele atingiu 1,0 em outubro passado, e isso leva a alguns problemas. Se você está procurando fazer algo obscuro, é possível que ninguém tenha escrito um pacote para essa funcionalidade ainda. Os pacotes que existem são mais propensos a ter bugs, simplesmente porque eles não existem há tempo suficiente para descobrir todos os problemas.
O dimensionamento também pode ser um pouco desconhecido com o Meteor. Existem muitos sites Meteor que escalam para uma quantidade razoável de usuários, mas poucos sites muito grandes - nada na ordem do Facebook ou LinkedIn, com dezenas ou centenas de milhões de usuários.
No entanto, para a maioria dos aplicativos, o Meteor é uma escolha perfeita, pois é uma chance de reduzir o tempo de desenvolvimento e participar do início de algo grande.