DOCSEARCHbyAlgolia
Submit Docs

Meteor Documentation

website·Indexed 41 days ago

https://v3-docs.meteor.com/

Documentation for the Meteor framework, covering the build system, application structure, and security. Includes detailed guides on the Accounts system (authentication, 2FA, and OAuth services like Google, Facebook, and GitHub), reactive rendering with Blaze, Apollo and GraphQL integration, and version updates through v3.5.2.

Tokens
171.5K
Snippets
1K
Records
1.3K
Agent score
61%

What's inside Meteor

  1. Overview of the Meteor full-stack platform

    Meteor is a full-stack JavaScript platform used for building modern web and mobile applications. It enables development in a single language (JavaScript or TypeScript) across the application server, web browser, and mobile devices. Key architectural features include:

    • Data on the wire: The server sends data instead of HTML, and the client handles rendering.
    • Full stack reactivity: The UI automatically reflects the current state of the data with minimal effort.
    • Front-end flexibility: Supports various frameworks including React, Vue, Blaze, Svelte, and Solid.
    • Simplified Integration: Uses 'Methods' (a built-in Remote Procedure Call system) for seamless communication between the back-end and front-end.
    • Built-in Authentication: Includes a ready-to-use Login and Accounts package.

  2. Overview of EJSON (Extended JSON) in Meteor

    EJSON is an extension of JSON used by Meteor to support data types that standard JSON cannot represent. All EJSON serializations remain valid JSON. Meteor uses EJSON for publishers, method arguments/results, MongoDB databases, and Session variables. Supported types include:

    • Date (JavaScript Date)
    • Binary (JavaScript Uint8Array)
    • Special numbers (NaN, Infinity, -Infinity)
    • Regular expressions (JavaScript RegExp)
    • User-defined custom types.
    {
  "d": { "$date": 1358205756553 },
  "b": { "$binary": "c3VyZS4=" }
}

  4. Overview of using Solid with Meteor.js 3

    Meteor.js 3 supports integration with Solid, a modern UI framework that uses a compiler to produce efficient DOM updates without a virtual DOM. Solid's fine-grained reactivity (using signals, effects, and resources) integrates with Meteor's reactive data sources, such as Tracker and Minimongo, allowing the UI to update automatically as data changes. Developers familiar with React-like JSX can easily adopt Solid in Meteor applications. Additionally, Meteor packages designed for other frameworks, such as accounts-ui, remain compatible and usable within a Solid app.

  5. Overview of Meteor Methods

    Meteor Methods are a remote procedure call (RPC) system used to handle user input and data updates from the client to the server. They function similarly to HTTP POST requests but are optimized for modern web apps. Methods are tightly integrated with Meteor's pub/sub and data loading systems to enable Optimistic UI, allowing the client to simulate server-side actions for a more responsive user experience. To enable Optimistic UI, Methods must be defined in common code loaded on both the client and the server.

  6. Overview of Meteor Modern Build Stack

    Meteor's modern build stack improves build speed and productivity by combining two main components: Meteor Bundler Optimizations (which integrate SWC for faster transpilation) and Rspack Bundler Integration (which handles app code bundling to provide tree shaking, full ESM support, and compatibility with standard plugins). New Meteor apps have these enabled by default.

  7. Overview of Browser Policy security packages

    The browser-policy family of packages allows you to set security policies enforced by the browser to prevent cross-site scripting (XSS) and clickjacking.

    • browser-policy: Enables both framing and content policies with a starter configuration.
    • browser-policy-framing: Specifically manages the X-Frame-Options header to control which sites can frame your app.
    • browser-policy-content: Specifically manages the Content-Security-Policy (CSP) and X-Content-Type-Options headers to control where your app can load content from.

    Important: BrowserPolicy functions must be called on the server in top-level application code or within Meteor.startup. They cannot be used in client code.

  8. Overview of Meteor Change Streams Observer Driver

    Meteor provides a Change Streams–based observe driver that delivers real-time updates by hooking directly into MongoDB Change Streams. This allows the driver to watch collection activity and push mutations to clients without requiring oplog tailing. It is the default reactivity driver starting in Meteor 3.5.

  9. Overview of Meteor's Reactive Dependency Tracking

    Meteor uses a dependency tracking system that automatically reruns computations (like template rendering) when their data sources—such as Session variables or database queries—change. Developers do not need to manually declare dependencies; when a reactive function is called, it automatically registers the current Computation object. If the data changes, the computation is 'invalidated' and will rerun during the next flush cycle.

  10. Overview of Meteor Wormhole

    Meteor Wormhole is a server-only package for Meteor 3.4+ that bridges Meteor methods to external AI assistants and HTTP clients. It provides:

    • MCP (Model Context Protocol) Support: Turns methods into tools for AI assistants like Claude, GPT, Cursor, and VS Code Copilot.
    • REST API: Creates a POST /api/<method> endpoint for every exposed method.
    • OpenAPI 3.1 & Swagger UI: Auto-generates API specifications and provides interactive docs at /api/docs.
    • Input Validation: Converts JSON Schemas to Zod for parameter validation.

  12. Overview of Meteor Publications and Subscriptions

    Meteor uses the Distributed Data Protocol (DDP) to allow bidirectional data transfer. A publication is a named API on the server that defines a set of data to be sent to the client. A subscription is a client-side request to connect to a publication. This creates a 'pipe' between a server-side MongoDB collection and the client-side Minimongo cache, providing an initial batch of data followed by real-time incremental updates.