Meteor API Manual

Section

Breaking changes - Migrating to Meteor 1.3
Mobile - Breaking changes - Migrating to Meteor 1.3
Recommended change: use modules - Migrating to Meteor 1.3
Recommended changes: package authors - Migrating to Meteor 1.3
Recommended changes: Testing - Migrating to Meteor 1.3
Full app testing - Recommended changes: Testing - Migrating to Meteor 1.3
Module testing - Recommended changes: Testing - Migrating to Meteor 1.3
Recommended changes: Mobile - Migrating to Meteor 1.3
Install React from npm - Migrating to Meteor 1.3
Loading data with React - Install React from npm - Migrating to Meteor 1.3
Install Angular from npm - Migrating to Meteor 1.3
Existing Angular Atmosphere packages - Install Angular from npm - Migrating to Meteor 1.3
New guide articles - Migrating to Meteor 1.3
Features in core Meteor - Users and Accounts
userId in DDP - Features in core Meteor - Users and Accounts
accounts-base - Features in core Meteor - Users and Accounts
Fast prototyping with accounts-ui - Users and Accounts
Customizable UI: useraccounts - Users and Accounts
Use any router or UI framework - Customizable UI: useraccounts - Users and Accounts
Drop-in UI without routing - Customizable UI: useraccounts - Users and Accounts
Customizing templates - Customizable UI: useraccounts - Users and Accounts
Customizing routes - Customizable UI: useraccounts - Users and Accounts
Further customization - Customizable UI: useraccounts - Users and Accounts
Password login - Users and Accounts
Requiring username or email - Password login - Users and Accounts
Multiple emails - Password login - Users and Accounts
Case sensitivity - Password login - Users and Accounts
Email flows - Password login - Users and Accounts
Customizing accounts emails - Password login - Users and Accounts
OAuth login - Users and Accounts
Facebook, Google, and more - OAuth login - Users and Accounts
Logging in - OAuth login - Users and Accounts
Configuring OAuth - OAuth login - Users and Accounts
Calling service API for more data - OAuth login - Users and Accounts
Loading and displaying user data - Users and Accounts
Currently logged in user - Loading and displaying user data - Users and Accounts
The Meteor.users collection - Loading and displaying user data - Users and Accounts
Custom data about users - Users and Accounts
Add top-level fields onto the user document - Custom data about users - Users and Accounts
Adding fields on user registration - Custom data about users - Users and Accounts
Don’t use profile - Custom data about users - Users and Accounts
Publishing custom data - Custom data about users - Users and Accounts
Roles and permissions - Users and Accounts
alanning:roles - Roles and permissions - Users and Accounts
Per-document permissions - Roles and permissions - Users and Accounts
Spacebars - Blaze
Data contexts and lookup - Spacebars - Blaze
Calling helpers with arguments - Spacebars - Blaze
Template inclusion - Spacebars - Blaze
Attribute Helpers - Spacebars - Blaze
Rendering raw HTML - Spacebars - Blaze
Block Helpers - Spacebars - Blaze
Builtin Block Helpers - Spacebars - Blaze
Reusable components in Blaze - Blaze
Validate data context - Reusable components in Blaze - Blaze
Name data contexts to template inclusions - Reusable components in Blaze - Blaze
Prefer {{#each .. in}} - Reusable components in Blaze - Blaze
Pass data into helpers - Reusable components in Blaze - Blaze
Use the template instance - Reusable components in Blaze - Blaze
Use a reactive dict for state - Reusable components in Blaze - Blaze
Attach functions to the instance - Reusable components in Blaze - Blaze
Scope DOM lookups to the template instance - Reusable components in Blaze - Blaze
Use .js- selectors for event maps - Reusable components in Blaze - Blaze
Passing HTML content as a template argument - Reusable components in Blaze - Blaze
Pass callbacks - Reusable components in Blaze - Blaze
Use onRendered() for 3rd party libraries - Reusable components in Blaze - Blaze
Writing smart components with Blaze - Blaze
Subscribe from onCreated - Writing smart components with Blaze - Blaze
Fetch in helpers - Writing smart components with Blaze - Blaze
Reusing code in Blaze - Blaze
Composition - Reusing code in Blaze - Blaze
Libraries - Reusing code in Blaze - Blaze
Global Helpers - Reusing code in Blaze - Blaze
Understanding Blaze - Blaze
Re-rendering - Understanding Blaze - Blaze
Controlling re-rendering - Understanding Blaze - Blaze
Attribute helpers - Understanding Blaze - Blaze
Lookup order - Understanding Blaze - Blaze
Blaze and the build system - Understanding Blaze - Blaze
What is a view? - Understanding Blaze - Blaze
What does it do? - Build system
Reloads app on file change - What does it do? - Build system
Compiles files with build plugins - What does it do? - Build system
Combines and minifies code - What does it do? - Build system
Development vs. production - What does it do? - Build system
JavaScript transpilation - Build system
ES2015+ (recommended) - JavaScript transpilation - Build system
CoffeeScript - JavaScript transpilation - Build system
Templates and HTML - Build system
Blaze HTML templates - Templates and HTML - Build system
Blaze Jade templates - Templates and HTML - Build system
JSX for React - Templates and HTML - Build system
Angular templates - Templates and HTML - Build system
CSS and CSS pre-processors - Build system
Sass, Less, or Stylus? - CSS and CSS pre-processors - Build system
Source vs. import files - CSS and CSS pre-processors - Build system
Importing styles - CSS and CSS pre-processors - Build system
Sass - CSS and CSS pre-processors - Build system
Less - CSS and CSS pre-processors - Build system
Stylus - CSS and CSS pre-processors - Build system
PostCSS and Autoprefixer - Build system
juliancwirko:postcss - PostCSS and Autoprefixer - Build system
Minification - Build system
Benefits of consistent style - Code style
Easy to read code - Benefits of consistent style - Code style
Automatic error checking - Benefits of consistent style - Code style
Deeper understanding - Benefits of consistent style - Code style
JavaScript style guide - Code style
Use the ecmascript package - JavaScript style guide - Code style
Follow a JavaScript style guide - JavaScript style guide - Code style
Check your code with ESLint - Code style
Installing and running ESLint - Check your code with ESLint - Code style
Integrating with your editor - Check your code with ESLint - Code style
Meteor code style - Code style
Collections - Meteor code style - Code style
Methods and publications - Meteor code style - Code style
Files, exports, and packages - Meteor code style - Code style
Templates and components - Meteor code style - Code style
MongoDB collections in Meteor - Collections and Schemas
Server-side collections - MongoDB collections in Meteor - Collections and Schemas
Client-side collections - MongoDB collections in Meteor - Collections and Schemas
Local collections - MongoDB collections in Meteor - Collections and Schemas
Defining a schema - Collections and Schemas
Validating against a schema - Defining a schema - Collections and Schemas
The ValidationError - Defining a schema - Collections and Schemas
Designing your data schema - Collections and Schemas
Denormalization and multiple collections - Designing your data schema - Collections and Schemas
Designing for the future - Designing your data schema - Collections and Schemas
Using schemas on write - Designing your data schema - Collections and Schemas
defaultValue and data cleaning - Designing your data schema - Collections and Schemas
Hooks on insert/update/remove - Designing your data schema - Collections and Schemas
Abstracting denormalizers - Designing your data schema - Collections and Schemas
Migrating to a new schema - Collections and Schemas
Writing migrations - Migrating to a new schema - Collections and Schemas
Bulk changes - Migrating to a new schema - Collections and Schemas
Running migrations - Migrating to a new schema - Collections and Schemas
Breaking schema changes - Migrating to a new schema - Collections and Schemas
Caveats - Migrating to a new schema - Collections and Schemas
Associations between collections - Collections and Schemas
Collection helpers - Associations between collections - Collections and Schemas
Association helpers - Associations between collections - Collections and Schemas
Publications and subscriptions - Publications and Data Loading
Defining a publication - Publications and Data Loading
Organizing publications - Defining a publication - Publications and Data Loading
Subscribing to data - Publications and Data Loading
Stopping Subscriptions - Subscribing to data - Publications and Data Loading
Subscribe in UI components - Subscribing to data - Publications and Data Loading
Fetching data - Subscribing to data - Publications and Data Loading
Global subscriptions - Subscribing to data - Publications and Data Loading
Patterns for data loading - Publications and Data Loading
Subscription readiness - Patterns for data loading - Publications and Data Loading
Reactively changing subscription arguments - Patterns for data loading - Publications and Data Loading
Publication behavior when arguments change - Patterns for data loading - Publications and Data Loading
Paginating subscriptions - Patterns for data loading - Publications and Data Loading
Client-side data with reactive stores - Publications and Data Loading
Types of stores - Client-side data with reactive stores - Publications and Data Loading
Accessing stores - Client-side data with reactive stores - Publications and Data Loading
Updating stores - Client-side data with reactive stores - Publications and Data Loading
Advanced publications - Publications and Data Loading
Publishing relational data - Advanced publications - Publications and Data Loading
Complex authorization - Advanced publications - Publications and Data Loading
Custom publications with the low level API - Advanced publications - Publications and Data Loading
Subscription lifecycle - Advanced publications - Publications and Data Loading
Working with REST APIs - Publications and Data Loading
Loading data from a REST endpoint with a publication - Working with REST APIs - Publications and Data Loading
Accessing a publication as a REST endpoint - Working with REST APIs - Publications and Data Loading
Deploying Meteor Applications - Deployment and Monitoring
Deployment environments - Deploying Meteor Applications - Deployment and Monitoring
Environment variables and settings - Deploying Meteor Applications - Deployment and Monitoring
Other considerations - Deployment and Monitoring
Domain name - Other considerations - Deployment and Monitoring
SSL Certificate - Other considerations - Deployment and Monitoring
CDN - Other considerations - Deployment and Monitoring
Deployment options - Deployment and Monitoring
Galaxy (recommended) - Deployment options - Deployment and Monitoring
Meteor Up - Deployment options - Deployment and Monitoring
Custom deployment - Deployment options - Deployment and Monitoring
Deployment process - Deployment and Monitoring
Continuous deployment - Deployment process - Deployment and Monitoring
Rolling deployments and data versions - Deployment process - Deployment and Monitoring
Monitoring users via analytics - Deployment and Monitoring
Monitoring your application - Deployment and Monitoring
Understanding Meteor performance - Monitoring your application - Deployment and Monitoring
Monitoring with Galaxy - Monitoring your application - Deployment and Monitoring
Kadira - Monitoring your application - Deployment and Monitoring
Enabling SEO - Deployment and Monitoring
What is Meteor? - Introduction
Quick start - What is Meteor? - Introduction
Meteor resources - Introduction
What is the Meteor Guide? - Introduction
Target audience - What is the Meteor Guide? - Introduction
Example app - What is the Meteor Guide? - Introduction
Guide development - Introduction
Contributing - Guide development - Introduction
Goals of the project - Guide development - Introduction
What is a Method? - Methods
Defining and calling Methods - Methods
Basic Method - Defining and calling Methods - Methods
Advanced Method boilerplate - Defining and calling Methods - Methods
Advanced Methods with mdg:validated-method - Defining and calling Methods - Methods
Error handling - Methods
Throwing errors from a Method - Error handling - Methods
Handling errors - Error handling - Methods
Errors in Method simulation - Error handling - Methods
Calling a Method from a form - Methods
Loading data with Methods - Methods
Advanced concepts - Methods
Method call lifecycle - Advanced concepts - Methods
Benefits of Methods over REST - Advanced concepts - Methods
Calling a Method from another Method - Advanced concepts - Methods
Consistent ID generation and optimistic UI - Advanced concepts - Methods
Method retries - Advanced concepts - Methods
Historical comparison with allow/deny - Advanced concepts - Methods
Introduction to Meteor’s built-in mobile integration - Mobile
How does the Cordova integration in Meteor work? - Introduction to Meteor’s built-in mobile integration - Mobile
What environment does your Cordova app run in? - Introduction to Meteor’s built-in mobile integration - Mobile
Adding Cordova platforms to your app - Introduction to Meteor’s built-in mobile integration - Mobile
Installing prerequisites - Mobile
iOS - Installing prerequisites - Mobile
Android - Installing prerequisites - Mobile
Running your app on a mobile device for development - Mobile
How to run your app on an iOS device - Running your app on a mobile device for development - Mobile
How to run your app on an Android device - Running your app on a mobile device for development - Mobile
Using logging and remote debugging tools - Mobile
Understanding the different types of logs - Using logging and remote debugging tools - Mobile
How to remote debug your iOS app with Safari - Using logging and remote debugging tools - Mobile
How to remote debug your Android app with Chrome - Using logging and remote debugging tools - Mobile
Hot code push on mobile - Mobile
Updating apps in production - Hot code push on mobile - Mobile
Configuring your server for hot code push - Hot code push on mobile - Mobile
Recovering from faulty versions - Hot code push on mobile - Mobile
Using native device features with Cordova plugins - Mobile
Installing plugins - Using native device features with Cordova plugins - Mobile
Using plugins - Using native device features with Cordova plugins - Mobile
Adding Cordova-specific Javascript code to your application - Using native device features with Cordova plugins - Mobile
Accessing local files and remote resources - Mobile
Accessing local files - Accessing local files and remote resources - Mobile
Domain whitelisting - Accessing local files and remote resources - Mobile
Content Security Policy (CSP) - Accessing local files and remote resources - Mobile
Cross-Origin Resource Sharing (CORS) - Accessing local files and remote resources - Mobile
Configuring your app - Mobile
Metadata - Configuring your app - Mobile
Preferences - Configuring your app - Mobile
App icons and launch screens - Configuring your app - Mobile
Advanced build customization - Configuring your app - Mobile
Submitting your mobile app to the store - Mobile
Building your mobile app for production - Submitting your mobile app to the store - Mobile
How to submit your iOS app to the App Store - Submitting your mobile app to the store - Mobile
How to submit your Android app to the Play Store - Submitting your mobile app to the store - Mobile
Introduction - React
Installing and using React - Introduction - React
Using 3rd party packages - Introduction - React
React Components in Blaze - Introduction - React
Blaze Templates in React - Introduction - React
Using Meteor’s data system - React
Using createContainer - Using Meteor’s data system - React
Preventing re-renders - Using Meteor’s data system - React
Routing - React
Flow Router - Routing - React
React Router - Routing - React
Meteor and React - React
Using React in Atmosphere Packages - Meteor and React - React
Client-side Routing - URLs and Routing
Using Flow Router - URLs and Routing
Defining a simple route - URLs and Routing
URL pattern matching - Defining a simple route - URLs and Routing
Accessing Route information - URLs and Routing
The current route - Accessing Route information - URLs and Routing
Highlighting the active route - Accessing Route information - URLs and Routing
Rendering based on the route - URLs and Routing
Components as pages - URLs and Routing
Changing page when logged out - Components as pages - URLs and Routing
Changing Routes - URLs and Routing
Routing programmatically - Changing Routes - URLs and Routing
Storing data in the URL - Changing Routes - URLs and Routing
Redirecting - URLs and Routing
Redirecting dynamically - Redirecting - URLs and Routing
Redirecting after a user’s action - Redirecting - URLs and Routing
Advanced Routing - URLs and Routing
Missing pages - Advanced Routing - URLs and Routing
Analytics - Advanced Routing - URLs and Routing
Server Side Routing - Advanced Routing - URLs and Routing
Concept: Attack surface - Security
Avoid allow/deny - Concept: Attack surface - Security
Methods - Security
Validate all arguments - Methods - Security
mdg:validated-method - Methods - Security
Don’t pass userId from the client - Methods - Security
One Method per action - Methods - Security
Rate limiting - Methods - Security
Publications - Security
Rules about Methods still apply - Publications - Security
Always restrict fields - Publications - Security
Publications and userId - Publications - Security
Passing options - Publications - Security
Served files - Security
Secret server code - Served files - Security
Securing API keys - Security
Settings on the client - Securing API keys - Security
API keys for OAuth - Securing API keys - Security
SSL - Security
Security checklist - Security
Universal JavaScript - Application structure
ES2015 modules - Universal JavaScript - Application structure
Introduction to using import and export - Universal JavaScript - Application structure
Importing from packages - Universal JavaScript - Application structure
Using require - Universal JavaScript - Application structure
Exporting with CoffeeScript - Universal JavaScript - Application structure
File structure - Application structure
Example directory layout - File structure - Application structure
Structuring imports - File structure - Application structure
Startup files - File structure - Application structure
Importing Meteor “pseudo-globals” - File structure - Application structure
Default file load order - Application structure
Special directories - Default file load order - Application structure
Files outside special directories - Default file load order - Application structure
Splitting into multiple apps - Application structure
Sharing code - Splitting into multiple apps - Application structure
Sharing data - Splitting into multiple apps - Application structure
Sharing accounts - Splitting into multiple apps - Application structure
Introduction - Testing
Types of tests - Introduction - Testing
Challenges of testing in Meteor - Introduction - Testing
The ‘meteor test’ command - Testing
Driver packages - The ‘meteor test’ command - Testing
Recommended: Mocha - The ‘meteor test’ command - Testing
Test data - Testing
Generating test data - Test data - Testing
Mocking the database - Test data - Testing
Unit testing - Testing
A simple unit test - Unit testing - Testing
Running unit tests - Unit testing - Testing
Isolation techniques - Unit testing - Testing
Integration testing - Testing
Simple integration test - Integration testing - Testing
Full-app integration test - Integration testing - Testing
Running full-app tests - Integration testing - Testing
Creating data - Integration testing - Testing
Acceptance testing - Testing
Running acceptance tests - Acceptance testing - Testing
Creating data - Acceptance testing - Testing
Continuous Integration - Testing
Command line - Continuous Integration - Testing
CircleCI - Continuous Integration - Testing
UI components - User Interfaces
Reusable components - UI components - User Interfaces
Global data stores - UI components - User Interfaces
Smart components - UI components - User Interfaces
Visually testing reusable components - User Interfaces
User interface patterns - User Interfaces
Internationalization with tap:i18n - User interface patterns - User Interfaces
Event handling - User interface patterns - User Interfaces
User experience patterns - User Interfaces
Subscription readiness - User experience patterns - User Interfaces
Pagination - User experience patterns - User Interfaces
Optimistic UI - User experience patterns - User Interfaces
Indicating when a write is in progress - User experience patterns - User Interfaces
Unexpected failures - User experience patterns - User Interfaces
Animation - User Interfaces
Animating changes in visiblity - Animation - User Interfaces
Animating changes to attributes - Animation - User Interfaces
Animating page changes - Animation - User Interfaces
npm - Using Packages
npm on the client - npm - Using Packages
Installing npm packages - npm - Using Packages
Using npm packages - npm - Using Packages
npm shrinkwrap - npm - Using Packages
Atmosphere packages - Using Packages
Installing Atmosphere packages - Atmosphere packages - Using Packages
Using Atmosphere Packages - Atmosphere packages - Using Packages
Peer npm Dependencies - Atmosphere packages - Using Packages
Atmosphere package namespacing - Atmosphere packages - Using Packages
Asyncronous Callbacks - Using Packages
Meteor.bindEnvironment - Asyncronous Callbacks - Using Packages
Meteor.wrapAsync - Asyncronous Callbacks - Using Packages
Promises - Asyncronous Callbacks - Using Packages
Overriding packages with a local version - Using Packages
npm - Overriding packages with a local version - Using Packages
Atmosphere - Overriding packages with a local version - Using Packages
Using Shrinkpack - Using Packages
npm vs. Atmosphere - Writing Packages
Creating an npm package - Writing Packages
Including in your app - Creating an npm package - Writing Packages
Publishing your package - Creating an npm package - Writing Packages
Creating an Atmosphere package - Writing Packages
Adding files and assets - Writing Packages
Adding JavaScript - Adding files and assets - Writing Packages
Adding CSS - Adding files and assets - Writing Packages
Adding Sass, Less, or Stylus mixins/variables - Adding files and assets - Writing Packages
Adding other assets - Adding files and assets - Writing Packages
Exporting - Writing Packages
Dependencies - Writing Packages
Atmosphere dependencies - Dependencies - Writing Packages
npm dependencies - Dependencies - Writing Packages
Peer npm dependencies - Dependencies - Writing Packages
Cordova plugins - Writing Packages
Testing packages - Writing Packages
Peer npm dependencies - Testing packages - Writing Packages
Local packages vs. published packages - Writing Packages
Build plugins - Writing Packages
Types of build plugins - Build plugins - Writing Packages
Writing your own build plugin - Build plugins - Writing Packages
Caching - Build plugins - Writing Packages

Guide

Section

Class

Function

Package

Command