Tutorial de Meteor: Creación de aplicaciones web en tiempo real con Meteor

Publicado: 2022-03-11

Meteor es un marco JavaScript de pila completa para aplicaciones web y móviles. Ha existido desde 2011 y ha ganado una sólida reputación entre los desarrolladores de Meteor por ser una solución ideal y fácil de usar para la creación rápida de prototipos. Sin embargo, últimamente los desarrolladores se han dado cuenta de que Meteor ya no es solo para crear prototipos: está listo para usarse para desarrollo comercial. Con el arsenal de paquetes que proporciona, la base sólida de mongoDB/node.js en la que se basa y la flexibilidad de codificación que ofrece; Meteor facilita la creación de aplicaciones web robustas y seguras en tiempo real, manejando todo, desde la aplicación del navegador hasta el servidor o la base de datos.

Este tutorial de Meteor lo guiará a través de la creación de una aplicación web básica en Meteor: un catálogo simple que permite a los usuarios iniciar sesión y administrar una lista de libros.

¿Por qué usar Meteoro? La respuesta corta es, “porque Meteor es divertido”. Simplifica el desarrollo de aplicaciones web. Es fácil de aprender y le permite concentrarse más en la funcionalidad de su aplicación que en los conceptos básicos de sincronización de datos y publicación de páginas.

También tiene muchos comportamientos convenientemente integrados. Meteor realiza automáticamente actualizaciones en vivo, por lo que los cambios de datos se muestran inmediatamente en la ventana de su navegador, e incluso los cambios de código en la aplicación misma se envían a todos los navegadores y dispositivos en "tiempo real". Meteor tiene compensación de latencia incorporada, es fácil de implementar y tiene "paquetes" fáciles de instalar que manejan todo tipo de funcionalidad.

Aunque es un marco relativamente nuevo, muchas empresas emergentes ya están creando aplicaciones Meteor, incluidos servicios de escala relativamente grande como Respondly y Telescope.

Instalación de meteoritos y andamios

Instalar Meteor en sistemas *nix es una sola línea:

 curl https://install.meteor.com/ | sh

Aunque todavía no hay soporte oficial, su vista previa para Windows está funcionando muy bien. Los rumores son que el soporte de Windows se enviará con 1.1, que saldrá en abril o mayo de 2015. Como es de esperar de un marco inteligente como Meteor, arrancar una aplicación requiere que se invoque una sola línea de comando:

 meteor create book-list

Esto creará un directorio llamado "lista de libros" y lo completará con un código repetitivo y dependiente. Para ejecutar la aplicación, ingrese al directorio recién creado y ejecute:

 meteor

Abra http://localhost:3000 en su navegador web y verá lo siguiente:

También puede consultar la "versión 0" de nuestra aplicación en MeteorPad, un sitio que es como JSFiddle para Meteor: Lista de libros: Aplicación predeterminada

Meteor almacena sus vistas en archivos HTML. Si abrimos “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>

Meteor utiliza "Blaze", un motor de plantillas, para generar respuestas de estos archivos HTML. Las llaves dobles deberían ser familiares para cualquiera que haya usado Handlebars.js (u otros motores de plantillas similares), y cumplen una función similar aquí. Blaze examina las expresiones dentro de cada par de llaves dobles y reemplaza cada una con el valor que arrojan estas expresiones.

Este sencillo programa de ejemplo tiene solo dos expresiones entre llaves:

El primero, "{{> hola}}", le dice a Blaze que incluya una plantilla llamada "hola". Esa plantilla se define en la parte inferior del archivo, en la sección <template name=”hello”>.
El segundo, “{{counter}}”, es un poco más complicado. Para ver de dónde viene este valor de "contador", necesitamos 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 }); }

Algunas cosas requieren explicación aquí. Primero, la división en "si (Meteor.isClient)" y "si (Meteor.isServer)". Recuerde que Meteor es un marco de trabajo de pila completa, por lo que el código que escribe se ejecuta tanto en el servidor como en el cliente. Estos condicionales nos permiten limitar eso: el primer bloque se ejecuta solo en el cliente y el segundo se ejecuta solo en el servidor.

En segundo lugar, está la llamada "Session.setDefault", que inicializa una variable de sesión llamada "contador" en el navegador. Las variables de sesión actúan un poco como globales en Meteor (para bien y para mal). Sin embargo, esa variable de sesión no aparece directamente en "{{contador}}". En cambio, esa expresión de "contador" es un "ayudante", uno que se define en la sección "Template.hello.helpers". Este ayudante simplemente toma el valor de la variable de sesión y lo devuelve.

Tenga en cuenta que el ayudante es "reactivo". Esto significa que cada vez que cambia la variable de sesión, Meteor vuelve a ejecutar automáticamente esta función auxiliar que hace referencia a ella y Blaze actualiza automáticamente el navegador con el nuevo contenido.

El código del cliente también monitorea eventos, a través de "Template.hello.events". Identificamos el evento por tipo de evento y selector (en este caso, "botón de clic"), y luego le decimos a Meteor qué debe hacer ese evento. En este caso, la variable de sesión se incrementa, lo que vuelve a ejecutar la función auxiliar y, a su vez, vuelve a representar el contenido.

Visualización de datos estáticos

Todo esto está muy bien, pero no es la aplicación Meteor que queremos para este tutorial.

Comencemos a modificar esta aplicación: mostraremos una lista de libros estática y codificada. Por ahora, guardaremos la lista de libros en una variable de sesión. En el código "isClient", usaremos "Template.hello.rendered" para configurar la variable de sesión tan pronto como se represente la plantilla bookList:

 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"} ]); };

Luego, devolvemos esa variable de sesión con un nuevo ayudante en la plantilla "hola":

 Template.hello.helpers({ books: function () { return Session.get('books'); } });

Y mostrarlo en pantalla a través de la interpolación de variables en la plantilla "hola":

 <template name="hello"> <h3>Here are your books:</h3> {{ books }} </template>

Puede consultar este código en acción en Meteorpad: Lista de libros: Mostrar variable de sesión

Lo primero que debe notar es que el servidor Meteor detectó automáticamente los cambios en nuestro código base, envió el nuevo código a los clientes y solicitó al cliente que recargara. Incluso después de haber implementado una aplicación, podemos implementar cambios y actualizar automáticamente a nuestros clientes a través de inserciones de código activo.

Hasta ahora, esto es lo que obtenemos:

Ups, estamos mostrando mal los datos. Blaze obtiene puntos por precisión aquí (porque sí, es una variedad de objetos), pero vamos a tener que ser un poco más inteligentes si queremos mostrar nuestra lista de libros de una manera útil. Afortunadamente, Blaze hace que sea muy fácil trabajar con matrices de datos usando la directiva "#each":

 <h3>Here are your books:</h3> <UL> {{#each books}} <LI><i>{{title}}</i> by {{author}}</LI> {{/each}} </UL>

En Blaze, "#each" funciona un poco como la directiva "ng-repeat" de Angular: itera a través de la estructura de la matriz, establece el contexto actual para el objeto actual en la matriz y muestra repetidamente el HTML dentro de "{{#each …}}”. Así es como se ve nuestra lista de libros ahora:

En MeteorPad: Mostrar la variable de sesión correctamente

algo de limpieza

Antes de continuar, vamos a limpiar un poco nuestro código.

Meteor permite un gran margen de maniobra en la forma en que organiza su base de código. Como verá, solo hay unas pocas reglas estrictas: donde sea que coloque su HTML y JavaScript, Meteor lo encontrará. Esta flexibilidad es agradable, pero significa que es más importante para usted organizar su código de una manera que tenga sentido, para que no tenga que mantener un desorden desordenado gigante.

Primero, cambiemos el nombre de esta plantilla "hola" a algo significativo, como "lista de libros", y reemplacemos el código HTML repetitivo con esto:

 <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>

En segundo lugar, dividamos las partes "cliente" y "servidor" en archivos separados. En nuestro directorio de aplicaciones, configuraremos un subdirectorio "cliente" y un subdirectorio "servidor". Meteor sabrá automáticamente ejecutar los archivos "/cliente/" en el cliente y ejecutar los archivos "/servidor/" en el servidor. Es una buena convención poner el código de la plantilla en un archivo JavaScript con el nombre de la plantilla, así que pongamos nuestro código de cliente en "client/bookList.js". Podemos poner nuestro código de inicio de servidor actualmente vacío en "server/startup.js". Finalmente, saquemos el “

Tenga en cuenta que incluso después de todo este cambio, Meteor seguirá encontrando automáticamente todos nuestros archivos HTML y JavaScript. Siempre que un archivo esté en algún lugar de "/cliente/", Meteor sabrá ejecutarlo en el cliente. Siempre que un archivo esté en algún lugar de “/servidor/”, Meteor sabrá ejecutarlo en el servidor. Nuevamente, depende del desarrollador mantener las cosas organizadas.

Así que ahora nuestro código debería verse así:

lista-de-libros.html:

 <head> <title>book-list</title> </head> <body> {{> bookList}} </body>

cliente/listadelibros.html:

 <template name="bookList"> <h3>Here are some books:</h3> <UL> {{#each books}} <LI><i>{{title}}</i> by {{author}}</LI> {{/each}} </UL> </template>

cliente/listadelibros.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'); } });

servidor/inicio.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 de la ventana del navegador que apunta a http://localhost:3000, vaya a la consola del desarrollador y verifique el valor de "Libros". ¡Ahora debería ser una colección de Mongo! Intente ejecutar "Books.find().fetch()", y obtendrá una matriz vacía, lo cual tiene sentido, ya que aún no le hemos agregado ningún libro. Podemos intentar agregarle elementos en la consola:

 Books.insert({title: "To Kill a Mockingbird", author: "Harper Lee"})

Agregar cosas en la consola es bastante tedioso. En cambio, configuraremos las cosas para que cuando el servidor se inicie, insertemos automáticamente los datos del dispositivo en la base de datos. Así que regresemos a "server/startup.js" y agreguemos esto:

 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"}); } });

Ahora, cuando se inicie el servidor, si no hay datos presentes, agregaremos los datos del dispositivo. Podemos verificar esto volviendo a nuestra terminal, deteniendo el servidor de meteoritos y ejecutando este comando:

 meteor reset

Nota: rara vez necesitará este comando, porque restablece, es decir, borra , la base de datos que está usando Meteor. Si su aplicación Meteor tiene datos de usuario en la base de datos, no debe ejecutar este comando. Pero en este caso, simplemente borraremos cualquier dato de prueba que tengamos.

Ahora vamos a iniciar el servidor de nuevo:

 meteor

Al iniciar, Meteor ejecutará la rutina de inicio, verá que la base de datos está vacía y agregará los datos del dispositivo. En este punto, si vamos a la consola y escribimos “Books.find().fetch()”, obtenemos los cinco libros que teníamos antes.

Todo lo que queda para este paso es mostrar los libros en la pantalla. Afortunadamente, eso es tan simple como reemplazar "return Session.get('books');" con lo siguiente en el ayudante de "libros":

 return Books.find();

¡Y estamos de vuelta en el negocio! La aplicación ahora muestra datos de un cursor de base de datos, en lugar de la variable de sesión.

Compruébalo en MeteorPad: Moverse a la base de datos

Preocupaciones de seguridad

Prefacio esto diciendo: "no hagas esto".

¿Qué crees que sucedería si alguien iniciara esta aplicación en su navegador, fuera a la consola y escribiera "Books.remove({})"?

La respuesta es: acabarían con la colección.

Entonces, ese es un problema de seguridad bastante grande: nuestros usuarios tienen demasiado acceso a nuestra base de datos. Cualquier cliente puede acceder a toda la base de datos. No solo eso, cualquier cliente puede realizar cualquier cambio en toda la base de datos, incluido el borrado de datos ".remove({})".

Esto no es bueno, así que vamos a arreglarlo.

Meteor utiliza los llamados "paquetes" para agregar funcionalidad. Lo que los módulos son para Node.js y las gemas para Ruby, los paquetes son una bondad de funcionalidad agrupada para Meteor. Hay paquetes para todo tipo de cosas. Para navegar a través de lo que está disponible, echa un vistazo a la atmósfera.js.

La aplicación de meteoritos predeterminada que creamos con "meteor create" incluye dos paquetes llamados "autopublish" e "insecure". El primer paquete hace que los clientes tengan acceso automático a toda la base de datos, y el segundo hace que los usuarios puedan realizar cualquier acción en esa base de datos.

Quitemos esos. Podemos hacerlo ejecutando lo siguiente desde el directorio de la aplicación:

 meteor remove autopublish insecure

Cuando haya terminado, verá que los datos de la lista de libros desaparecen de la pantalla (ya que ya no tiene acceso a ellos), y si intenta una llamada "Books.insert", obtendrá el error: "insertar fallido : Acceso denegado". En MeteorPad: exceso de seguridad

Si no toma nada más de este tutorial de Meteor, recuerde esto: cuando esté implementando una aplicación Meteor, asegúrese de eliminar los paquetes de publicación automática e inseguros. Meteor tiene muchas buenas precauciones de seguridad, pero todas ellas son en vano si deja esos dos paquetes instalados.

Entonces, ¿por qué Meteor incluye automáticamente estos paquetes, si son un peligro para la seguridad? La razón es que, especialmente para los principiantes, esos dos paquetes hacen que sea más fácil comenzar: puede depurar y modificar fácilmente la base de datos desde la consola de un navegador. Pero es una buena práctica deshacerse de la publicación automática y la inseguridad lo antes posible.

Publicar y Suscribirse

Así que solucionamos ese enorme agujero de seguridad, pero introducimos dos problemas. Primero, ahora no tenemos acceso a la base de datos. En segundo lugar, no tenemos forma de interactuar con la base de datos.

Vamos a abordar el primer problema aquí. Meteor proporciona acceso seguro a una base de datos al hacer que el servidor "publique" un subconjunto de la base de datos y que el cliente se "suscriba" a esa publicación.

Primero, creemos “/server/publications.js”:

 Meteor.publish('books', function() { return Books.find({}); });

Y crearemos “/client/subscriptions.js”:

 Meteor.subscribe('books');

Compruébelo en MeteorPad: publique y suscríbase

El servidor “publica” un cursor que tiene acceso a todos los datos, y el cliente se “suscribe” a él en el otro extremo. El cliente usa esta suscripción para llenar una copia duplicada de la base de datos con todos los datos del cursor. Cuando accedemos a "Books.find().fetch()", vemos los cinco objetos y los vemos en la pantalla como antes.

La diferencia ahora es que es muy fácil limitar a lo que pueden acceder los clientes. Intente cambiar la publicación "buscar ()" a un subconjunto de los datos:

 Meteor.publish('books', function() { return Books.find({}, {limit:3}); });

Ahora el cliente solo ve tres de los cinco libros y no hay forma de llegar al resto. Esto no solo es una gran ayuda para la seguridad (no puedo ver las cuentas bancarias de los demás), sino que puede usarlo para repartir datos y evitar sobrecargar a un cliente.

Agregar nuevos libros

Hemos visto cómo otorgar a los clientes acceso de lectura a la base de datos de forma limitada y segura. Ahora, veamos el segundo problema: ¿cómo permitimos que los usuarios alteren la base de datos sin permitirles hacer lo que quieran? Deshacerse del paquete inseguro hizo que los clientes no tuvieran acceso en absoluto. Intentemos permitir la adición de libros nuevamente. En Meteor, hacemos esto agregando un "método" al servidor. Agreguemos un método, uno que agregue un nuevo libro, a “/lib/collections/books.js”:

 Meteor.methods({ addBook: function(bookData) { var bookID = Books.insert(bookData); return bookID; } });

Como puede ver, esto toma "bookData" (en este caso, ese es un objeto con los campos "título" y "autor") y lo agrega a la base de datos. Una vez que su cliente se recarga, podemos llamar a este método desde el cliente. Puedes ir a la consola e ingresar algo como esto:

 Meteor.call('addBook', {title: "A Tale of Two Cities", author: "Charles Dickens"})

¡Y listo! Obtienes otro libro en la lista de libros. Usar la consola es intolerablemente complicado, así que sigamos adelante y agreguemos un formulario simple al final de la plantilla "bookList" que nos permitirá agregar nuevos libros:

 <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>

Y podemos conectar eso a JavaScript usando un caso de evento, como teníamos en la aplicación de prueba 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}) } });

Puedes ver esto en acción en MeteorPad: Métodos

Cuando teníamos inseguro y publicación automática, los clientes podían acceder y modificar toda la base de datos. Ahora, con la inseguridad y la publicación automática desaparecidas, pero con publicaciones, suscripciones y métodos, los clientes pueden acceder a la base de datos e interactuar con ella de manera controlada.

En una nota al margen: también puede abordar los problemas de seguridad en Meteor usando "reglas de permitir y denegar". Puede obtener más información sobre estos y algunos motivos por los que prefiero el enfoque anterior en discovermeteor.com.

Autenticacion de usuario

Puede parecer que acabamos de dar la vuelta al punto de partida, pero hay una diferencia importante: ahora es muy fácil para nosotros limitar el acceso a la base de datos. Para ver cómo funciona esto, intentemos agregar usuarios a esta aplicación. Agregaremos un sistema de inicio de sesión a nuestra aplicación y luego, en lugar de que todos los clientes trabajen con una lista de libros para todo el sistema, haremos que cada usuario solo pueda agregar o leer su propia lista de libros.

Vaya al directorio de la aplicación e instale dos paquetes:

 meteor add accounts-ui accounts-password

Ahí. Acabas de agregar un sistema de inicio de sesión a la aplicación. Ahora solo necesitamos agregar la interfaz de usuario de inicio de sesión a book-list.html. Ponga esta sola línea en la parte superior del cuerpo:

 {{> loginButtons}}

Debería ver un aviso de inicio de sesión en la parte superior de la pantalla:

Tenga en cuenta que si hace clic en el enlace de inicio de sesión, le pedirá una dirección de correo electrónico y una contraseña. Podemos cambiar eso a un sistema de inicio de sesión de nombre de usuario/contraseña simple creando “/client/config.js” con lo siguiente:

 Accounts.ui.config({ passwordSignupFields: "USERNAME_ONLY" });

En este punto, puede escribir "Meteor.userId ()" en la consola y devolverá "nulo". Puede intentar hacer clic en el enlace para crear una cuenta. Llamar a "Meteor.userId()" ahora debería devolver una cadena de ID. El servidor tiene acceso a esta misma información (como "this.userId"), por lo que es trivial hacer que el método "agregar libros" obligue al usuario a iniciar sesión e incluya un campo de ID de usuario:

 Meteor.methods({ addBook: function(bookData) { if (this.userId) { bookData.userID = this.userId; var bookID = Books.insert(bookData); return bookID; } } });

Ahora solo resta limitar el cliente, mostrando solo los libros que ha agregado este usuario. Usamos la capacidad de la publicación para restringir a qué tiene acceso el cliente:

 Meteor.publish('books', function() { return Books.find({userID: this.userId}); });

Ahora, la publicación solo encuentra libros de este usuario en particular. Incluso podemos acceder al ID de usuario desde las expresiones de Blaze como “{{currentUser}}”; y podemos usar esto, con una directiva "{{#if}}" (que hace exactamente lo que crees que hace), para mostrar datos solo cuando el usuario haya iniciado sesión:

 <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>

Mira el resultado final en MeteorPad: Usuarios

Despliegue

Ahora podemos implementar esta aplicación Meteor en Internet. Hacemos esto yendo al directorio de la aplicación en una terminal y ejecutando:

 meteor deploy <your app's name>.meteor.com

Asegúrese de reemplazar "<nombre de su aplicación>" con un nombre corto real para la instancia de la aplicación. Ejecutar este comando le pedirá que configure una cuenta con Meteor, y luego colocará su nueva aplicación en los servidores de prueba de Meteor para que pueda probarla en Internet.

Para una demostración rápida, esta solución de meteor.com es todo lo que necesita. El equipo de Meteor no ha anunciado límites explícitos de almacenamiento o ancho de banda en sus servidores. La única limitación notable es que si su aplicación no se usa durante mucho tiempo, el sitio tarda unos segundos en activarse para el próximo usuario.

Dicho esto, meteoro.com no está diseñado para uso comercial. Pero cuando pasa a producción, hay empresas de plataforma como servicio como Modulus y Digital Ocean que facilitan la implementación de aplicaciones Meteor. Si desea implementar una aplicación Meteor en su propio servidor, "Meteor Up" también simplifica el proceso.

Próximos pasos

¡Felicidades! En su búsqueda para aprender Meteor, ahora ha creado e implementado una aplicación web Meteor en tiempo real muy simple. Obviamente, este es solo un pequeño primer paso hacia todo un universo de características y funcionalidades. Si le gusta lo que ha visto hasta ahora, le recomiendo Your First Meteor Application de David Turnbull, que guía a los lectores a través de la creación de una aplicación más complicada, con más información sobre las características de los meteoritos en el camino. Está disponible como libro para Kindle por un módico precio y como PDF gratuito en el sitio web de Turnbull.

También querrá explorar los paquetes disponibles para Meteor. Nueve de cada diez veces, la respuesta a "¿cómo hago <x> en Meteor?" es “hay un paquete para eso”. "¿Cómo agrego enrutamiento a mi aplicación?" Usas Iron Router. "¿Cómo proporciono una API RESTful?" Utiliza RESTivus. “¿Cómo incluyo pruebas unitarias?” Usas Velocidad. "¿Cómo agrego validaciones de esquema?" Usas Collection2. Puede perderse fácilmente en Atmosphere.js mirando todos los paquetes disponibles.

¿Por qué no usar Meteor?

Como puede ver en este tutorial, Meteor es simple y divertido para escribir aplicaciones, pero sería negligente si no mencionara los inconvenientes.

Meteor es todavía relativamente inmaduro. Llegó a 1.0 en octubre pasado, y eso genera algunos problemas. Si está buscando hacer algo oscuro, es posible que nadie haya escrito un paquete para esa funcionalidad todavía. Es más probable que los paquetes que existen tengan errores, simplemente porque no han existido el tiempo suficiente para detectar todos los problemas.

La escala también puede ser algo desconocida con Meteor. Hay muchos sitios de Meteor que escalan a cantidades razonables de usuarios, pero pocos sitios muy grandes, nada del orden de Facebook o LinkedIn, con decenas o cientos de millones de usuarios.

Sin embargo, para la mayoría de las aplicaciones, Meteor es una opción perfecta, ya que es una oportunidad para reducir el tiempo de desarrollo y participar en el comienzo de algo grandioso.