Cover

Copyright

Credits

Preface

Table of Contents

Module 1: Building Single-page Web Apps with Meteor

Chapter 1: Getting Started with Meteor

The full-stack framework of Meteor

Meteor's requirements

Installing Meteor

Creating our first app

Adding basic packages

Variable scopes

Meteor's folder conventions and loading order

Meteor's command-line tool

Summary

Chapter 2: Building HTML Templates

Writing templates in Meteor

Building the basic templates

Adding templates and partials

Displaying data with template helpers

Setting the data context for a template

"this" in template helpers and template callbacks

Adding events

Block helpers

Listing posts

Spacebars syntax

Summary

Chapter 3: Storing Data and Handling Collections

Meteor and databases

Setting up a collection

Adding post examples

Querying a collection

Updating a collection

Database everywhere

Differences between client and server collections

Summary

Chapter 4: Controlling the Data Flow

Syncing data – the current Web versus the new Web

Removing the autopublish package

Publishing data

Publishing only parts of data

Publishing specific fields

Lazy loading posts

Switching subscriptions

Some notes on data publishing

Summary

Chapter 5: Making Our App Versatile with Routing

Adding the iron:router package

Setting up the router

Switching to a layout template

Adding another route

Moving the posts subscription to the Home route

Setting up the post route

Changing the website's title

Summary

Chapter 6: Keeping States with Sessions

Meteor's session object

Using sessions in template helpers

Rerunning functions reactively

Using autorun in a template

The reactive session object

Summary

Chapter 7: Users and Permissions

Meteor's accounts packages

Adding the accounts packages

Adding admin functionality to our templates

Creating the template to edit posts

Creating the admin user

Creating routes for the admin

Summary

Chapter 8: Security with the Allow and Deny Rules

Adding a function to generate slugs

Creating a new post

Editing posts

Restricting database updates

Adding a deny rule

Adding posts using a method call

Calling the method

Summary

Chapter 9: Advanced Reactivity

Reactive programming

Building a simple reactive object

Creating an advanced timer object

Reactive computations

Summary

Chapter 10: Deploying Our App

Deploying on meteor.com

Deploying on other servers

Outlook

Summary

Chapter 11: Building Our Own Package

The structure of a package

Creating our own package

Releasing our package to the public

Summary

Chapter 12: Testing in Meteor

Types of tests

Testing packages

Testing our meteor app

Acceptance tests

Summary

Module 2: Meteor Cookbook

Chapter 1: Optimizing Your Workflow

Introduction

Installing Meteor

Finding documentation for Meteor

Getting help with questions

Setting up your project file structure

Setting up your development environment

Using the web console

Deploying a test app to Meteor

Deploying to Meteor using a CNAME redirect

Deploying to a custom hosted environment

Deploying with Meteor Up (MUP)

Using CoffeeScript

Using CSS compilers

Chapter 2: Customizing with Packages

Introduction

Adding Meteor packages

Removing Meteor packages

Discovering new packages with Atmosphere

Creating a multipage application with Iron Router

Building a custom package

Using npm modules

Publishing custom packages to Atmosphere

Chapter 3: Building Great User Interfaces

Introduction

Inserting templates with Spacebars

Inserting raw HTML using triple braces

Creating dynamic lists

Building a smooth interface with Bootstrap

Creating customized global helpers

Creating custom components

Using reactivity with HTML attributes

Using dynamic templates

Animating DOM elements

Chapter 4: Creating Models

Introduction

Implementing a simple collection

Using the Session object

Sorting with MongoDB queries

Filtering with MongoDB queries

Creating upsert MongoDB queries

Implementing a partial collection

Chapter 5: Implementing DDP

Introduction

Reading the DDP stream

Using client-only collections

Implementing multiserver DDP

Integrating DDP with other technologies

Chapter 6: Mastering Reactivity

Introduction

Creating and consuming a reactive value

Using Ajax query results in ReactiveVar

Making a custom library reactive

Updating Blaze templates without Mongo

Using inline data to modify UI elements reactively

Integrating a jQuery UI

Chapter 7: Using Client Methods

Introduction

Creating dynamic graphs with SVG and Ajax

Using the HTML FileReader to upload images

Creating a coloring book with the Canvas element

Chapter 8: Integrating Third-party Libraries

Introduction

Using npm packages directly

Building graphs with D3.js

Creating cutting-edge UIs with Polymer

Chapter 9: Securing Your Application

Introduction

Basic safety – turning off autopublish

Basic safety – removing insecure

Securing data transactions with allow and deny

Hiding data with façades

Protecting the client with browser-policy

Chapter 10: Working with Accounts

Introduction

Implementing OAuth accounts packages

Customizing the accounts login

Performing two-factor authentication

Chapter 11: Leveraging Advanced Features

Introduction

Building custom server methods

Creating custom EJSON objects

Handling asynchronous events

Using asynchronous functions

Chapter 12: Creating Useful Projects

Introduction

Creating RESTful web services

Creating a complete app with Iron Router

Deploying apps to mobile devices

Adding social sharing

Module 3: Meteor Design Patterns

Chapter 1: Getting Started with Meteor

CoffeeScript for Meteor

Jade for Meteor

Stylus for Meteor

Templates, helpers, and events

The event loop and the merge box

The beginning of our online shop

Summary

Chapter 2: Publish and Subscribe Patterns

Template-level subscriptions

Database relationships

Publishing with relations

Aggregation publishers

External API publishers

Summary

Chapter 3: Front-end Patterns

Responsive design

Super helpers

Variable types

Forms

Loading data

Animations and transitions

SEO

Summary

Chapter 4: Application Patterns

Filtering and paging collections

Security

External APIs

Summary

Chapter 5: Testing Patterns

Behavior tests

Unit tests

Summary

Chapter 6: Deployment

Setting up Modulus

Setting up Compose

Setting up Kadira

Setting up an SSL certificate

Summary

Bibliography