mongofire 6.5.3 → 6.5.6

package/README.md

@@ -1,7 +1,7 @@
 # 🔥 MongoFire
 
-> **Offline-first MongoDB sync** — Local + Atlas feel like ONE database.  
-> Automatic conflict resolution, Mongoose plugin, zero boilerplate.
+> **Offline-first MongoDB sync** — Local + Atlas feel like ONE database.
+> Drop-in production setup, automatic connection management, zero boilerplate.
 
 [![npm version](https://img.shields.io/npm/v/mongofire)](https://www.npmjs.com/package/mongofire)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)
@@ -9,15 +9,27 @@
 
 ---
 
-## What it does
+## What is MongoFire?
 
-MongoFire keeps a **local MongoDB** and **MongoDB Atlas** in sync automatically.
+MongoFire keeps a **local MongoDB** and **MongoDB Atlas** in sync — automatically, reliably, and with zero boilerplate. Your app reads and writes to a local MongoDB instance that is always fast and always available, even when offline. MongoFire handles the rest in the background.
 
-- Your app reads/writes to local MongoDB — always fast, works offline
-- MongoFire tracks every change and uploads to Atlas when online
-- Downloads remote changes from Atlas in the background
-- If you go offline, changes queue up and sync when you reconnect
-- Conflicts resolved automatically (last-writer-wins with version vectors)
+> ⚡ **MongoFire manages every MongoDB connection for you.**
+> You never call `mongoose.connect()`. You never call `app.listen()` directly.
+> You import two functions — `startApp` and `plugin` — and everything else is automatic.
+
+**Features:**
+- **Offline-first** — your app never waits for the network
+- **Zero-config connection** — local MongoDB connects automatically on import
+- **`startApp(app, port)`** — replaces `app.listen()`, waits for DB, then opens the server
+- **Automatic sync** — uploads local changes and downloads remote ones on a configurable interval
+- **Real-time mode** — optional Atlas Change Streams for near-instant propagation
+- **Conflict resolution** — deterministic last-writer-wins with version tracking
+- **Per-field merge** — field-level LWW prevents data loss when devices edit different fields simultaneously
+- **Resumable bootstrap** — first sync streams from Atlas in batches, survives crashes
+- **Self-healing** — detects and recovers lost writes caused by crashes or local DB resets
+- **Auto-spawn mongod** — if MongoDB is not running, MongoFire starts it automatically
+- **CLI tools** — interactive commands for status, conflicts, reconciliation, and safe reset
+- **TypeScript** — full type declarations included
 
 ---
 
@@ -27,28 +39,31 @@ MongoFire keeps a **local MongoDB** and **MongoDB Atlas** in sync automatically.
 npm install mongofire
 ```
 
-**Peer dependencies** (install the ones you use):
+**Peer dependencies** (install once in your project):
 
 ```bash
-npm install mongodb mongoose
+npm install mongodb mongoose dotenv
 ```
 
 ---
 
-## Quick Start
+## Quick Start (3 steps)
 
-### 1. Init config files
+### Step 1 — Run the setup wizard
 
 ```bash
 npx mongofire init
 ```
 
-This creates:
-- `.env` — MongoDB connection strings
-- `mongofire.config.js` — which collections to sync
-- `mongofire.js` — app entry point
+This creates three files in your project root:
+
+| File | Purpose |
+|---|---|
+| `.env` | MongoDB connection strings |
+| `mongofire.config.js` | Collections to sync, intervals, options |
+| `mongofire.js` | The MongoFire entry point — **do not delete** |
 
-### 2. Fill in `.env`
+### Step 2 — Fill in `.env`
 
 ```env
 ATLAS_URI=mongodb+srv://user:pass@cluster0.xxxxx.mongodb.net/
@@ -56,234 +71,402 @@ LOCAL_URI=mongodb://127.0.0.1:27017
 DB_NAME=myapp
 ```
 
-### 3. Start sync in your app
+> `ATLAS_URI` is optional — omit it to run in local-only mode during development.
+
+### Step 3 — Use MongoFire in your project
+
+**`server.js` — your Express entry point:**
+
+```js
+// ESM
+import express from 'express';
+import cors from 'cors';
+import cookieParser from 'cookie-parser';
+import { startApp } from './mongofire.js';   // ← import from YOUR mongofire.js
+
+import authRoutes    from './routes/auth.routes.js';
+import studentRoutes from './routes/student.routes.js';
+
+const app = express();
+app.use(express.json());
+app.use(cookieParser());
+app.use(cors({ origin: process.env.FRONTEND_URL, credentials: true }));
+
+app.use('/auth',     authRoutes);
+app.use('/students', studentRoutes);
+
+// ✅ Replaces app.listen() — waits for local DB then starts the server
+startApp(app, process.env.PORT || 3000);
+```
 
 ```js
 // CommonJS
-const mongofire = require('mongofire');
-const config    = require('./mongofire.config');
+const express = require('express');
+const { startApp } = require('./mongofire');
 
-await mongofire.start(config);
+const app = express();
+app.use(express.json());
 
-// ESM
-import mongofire from 'mongofire';
-import config from './mongofire.config.js';
+app.use('/auth', require('./routes/auth.routes'));
 
-await mongofire.start(config);
+startApp(app, process.env.PORT || 3000);
 ```
 
-### 4. Add the plugin to your Mongoose schema
+**`models/User.js` — attach the plugin to your Mongoose schemas:**
 
 ```js
-const mongofire = require('mongofire');
+// ESM — from a file inside models/
+import mongoose from 'mongoose';
+import { plugin } from '../mongofire.js';   // ← note: ../ because models/ is one level deep
 
 const UserSchema = new mongoose.Schema({
-  name: String,
-  email: String,
-  userId: mongoose.Types.ObjectId,
+  name:      String,
+  email:     { type: String, unique: true },
+  updatedAt: Date,
 });
 
-// Track changes on the 'users' collection
-// ownerField: field used for per-user data isolation (multi-tenant)
-UserSchema.plugin(mongofire.plugin('users', { ownerField: 'userId' }));
+UserSchema.plugin(plugin('users'));  // collection name must match mongofire.config.js
 
-const User = mongoose.model('User', UserSchema);
+export default mongoose.model('User', UserSchema);
 ```
 
+```js
+// CommonJS — from a file inside models/
+const mongoose = require('mongoose');
+const { plugin } = require('../mongofire');   // ← note: ../ one level up
+
+const StudentSchema = new mongoose.Schema({
+  name:      String,
+  grade:     Number,
+  updatedAt: Date,
+});
+
+StudentSchema.plugin(plugin('students'));
+
+module.exports = mongoose.model('Student', StudentSchema);
+```
+
+> **Critical:** The import path is always a **relative path** to `mongofire.js` in your project root.
+> It is **never** `'mongofire'` (the npm package name).
+> From `server.js` (root) → `'./mongofire.js'`
+> From `models/User.js` (one level deep) → `'../mongofire.js'`
+
 ---
 
-## Config Options
-
-| Option | Type | Default | Description |
-|---|---|---|---|
-| `collections` | `string[]` | *required* | Collection names to sync |
-| `localUri` | `string` | `mongodb://localhost:27017` | Local MongoDB URI |
-| `atlasUri` | `string` | `null` | Atlas connection string |
-| `dbName` | `string` | `'mongofire'` | Database name |
-| `syncInterval` | `number` | `30000` (polling) / `5000` (realtime) | Polling interval in ms |
-| `batchSize` | `number` | `200` | Docs per upload/download batch |
-| `syncOwner` | `string\|fn` | `'*'` | Owner key for multi-tenant filtering. If a function, throwing will **abort** the sync to prevent unintended data access |
-| `realtime` | `boolean` | `false` | Use Atlas Change Streams for instant sync |
-| `onSync` | `function` | `null` | Called after each sync cycle |
-| `onError` | `function` | `null` | Called on sync errors |
+## Project folder structure
+
+```
+backend/
+├── mongofire.js          ← Generated by init — the bridge between your app and MongoFire
+├── mongofire.config.js   ← Your sync configuration
+├── .env                  ← Connection strings (never commit this)
+├── server.js             ← import { startApp } from './mongofire.js'
+├── models/
+│   ├── User.js           ← import { plugin } from '../mongofire.js'
+│   └── Student.js        ← import { plugin } from '../mongofire.js'
+└── routes/
+    ├── auth.routes.js
+    └── student.routes.js
+```
 
 ---
 
-## Events
+## What `startApp()` does
 
-```js
-mongofire.on('ready',           ()  => console.log('MongoFire started'));
-mongofire.on('online',          ()  => console.log('Atlas connected'));
-mongofire.on('offline',         ()  => console.log('Working locally'));
-mongofire.on('sync',            (r) => console.log('Sync result:', r));
-mongofire.on('conflict',        (c) => console.warn('Conflict detected:', c));
-mongofire.on('realtimeStarted', ()  => console.log('Change streams active'));
-mongofire.on('stopped',         ()  => console.log('Shut down cleanly'));
-mongofire.on('error',           (e) => console.error('Sync error:', e));
+`startApp(app, port)` replaces `app.listen()`. It:
+
+1. Waits for local MongoDB to be fully connected
+2. Calls `app.listen(port)` only after the DB is ready
+3. Logs `🚀 [MongoFire] Server ready on port <port>` on success
+4. If the local DB fails: logs a descriptive error and exits with code 1
+
+**Console output on startup:**
+
+```
+✅ [MongoFire] Local MongoDB connected
+🚀 [MongoFire] Server ready on port 3000
+🌐 [MongoFire] Atlas connected — sync active
+🔄 [MongoFire] Sync complete — ↑2 uploaded  ↓5 downloaded  🗑 0 deleted
 ```
 
-### `conflict` event
+---
 
-Emitted when a local write conflicts with a concurrent remote change. Use this to notify users or trigger a re-fetch:
+## Config Options (`mongofire.config.js`)
 
 ```js
-mongofire.on('conflict', ({ collection, docId, localVersion, remoteVersion, op }) => {
-  console.warn(`Conflict on ${collection}/${docId}`);
-  console.warn(`  Local was at version ${localVersion}, Atlas is at ${remoteVersion}`);
-  // Fetch the latest remote doc and re-apply your changes if needed
-});
+export default {
+  localUri:  process.env.LOCAL_URI || 'mongodb://127.0.0.1:27017',
+  atlasUri:  process.env.ATLAS_URI,
+  dbName:    process.env.DB_NAME   || 'myapp',
+
+  collections: ['users', 'students', 'orders'],  // every collection your app uses
+
+  syncInterval: 30000,   // ms between sync cycles (minimum 500)
+  batchSize:    200,
+  syncOwner:    '*',     // '*' = sync all  |  'userId' = per-user isolation
+  realtime:     false,   // true = Atlas Change Streams
+  cleanDays:    7,
+
+  onSync(result) {
+    if (result.uploaded + result.downloaded + result.deleted > 0)
+      console.log(`Synced: ↑${result.uploaded} ↓${result.downloaded}`);
+  },
+  onError(err) { console.error('Sync error:', err.message); },
+};
 ```
 
+| Option              | Type           | Default                              | Description                                             |
+|---------------------|----------------|--------------------------------------|---------------------------------------------------------|
+| `collections`       | `string[]`     | **required**                         | Collection names to sync                                |
+| `localUri`          | `string`       | `'mongodb://127.0.0.1:27017'`        | Local MongoDB URI                                       |
+| `atlasUri`          | `string`       | `null`                               | Atlas URI. Omit for local-only mode                     |
+| `dbName`            | `string`       | `'myapp'`                            | Database name                                           |
+| `syncInterval`      | `number`       | `30000` (`5000` if `realtime:true`)  | Polling interval in ms (minimum: 500)                   |
+| `batchSize`         | `number`       | `200`                                | Documents per batch (1–10 000)                          |
+| `syncOwner`         | `string\|fn`   | `'*'`                                | Owner filter — see Multi-Tenant section                 |
+| `realtime`          | `boolean`      | `false`                              | Enable Atlas Change Streams                             |
+| `cleanDays`         | `number`       | `7`                                  | Auto-clean synced records older than N days             |
+| `onSync`            | `function`     | `null`                               | Called after each sync cycle                            |
+| `onError`           | `function`     | `null`                               | Called when a sync cycle throws                         |
+| `reconcileOnStart`  | `boolean`      | `true`                               | Scan for lost writes at startup                         |
+
 ---
 
-## API
+## Common import mistakes
 
-### `mongofire.start(config)` → `Promise<MongoFire>`
-Connect and start background sync. Concurrent calls are safe — all await the same init.
+### ❌ Wrong — using the npm package name
 
-### `mongofire.stop(timeoutMs?)` → `Promise<void>`
-Flush pending ops, wait for active sync, close all connections. Default timeout: 10 seconds.
+```js
+import { plugin } from 'mongofire';       // ❌ ERR_MODULE_NOT_FOUND
+const { plugin } = require('mongofire');  // ❌ wrong unless mongofire is installed globally
+```
 
-### `mongofire.sync(type?)` → `Promise<SyncResult>`
-Manually trigger a sync. `type` can be `'required'` (default) or `'all'`. Rapid successive calls are throttled automatically.
+### ✅ Correct — relative path to your local mongofire.js
 
-### `mongofire.status()` → `Promise<SyncStatus>`
-Get pending op counts and online/realtime status.
+```js
+// server.js (same folder as mongofire.js)
+import { startApp, plugin } from './mongofire.js';
 
-### `mongofire.clean(days?)` → `Promise<number>`
-Delete old sync records older than `days` days (default: **7**). Returns count of deleted records.
+// models/User.js (one folder deep)
+import { plugin } from '../mongofire.js';
 
-### `mongofire.plugin(collectionName, options?)`
-Returns a Mongoose schema plugin. Options:
+// routes/user.routes.js (one folder deep)
+import { plugin } from '../mongofire.js';
+```
 
-| Option | Type | Default | Description |
-|---|---|---|---|
-| `ownerField` | `string` | `null` | Dot-path to owner key field (e.g. `'userId'` or `'org._id'`) |
-| `batchSize` | `number` | `200` | Batch size for bulk operations |
-| `concurrency` | `number` | `8` | Concurrent change tracking calls per batch |
+---
+
+## Events
+
+```js
+import { mongofire } from './mongofire.js';
+
+mongofire.on('localReady', () => console.log('Local DB connected'));
+mongofire.on('online',     () => console.log('Atlas connected'));
+mongofire.on('offline',    () => console.log('Working offline'));
+mongofire.on('sync',       (r) => console.log('Synced:', r));
+mongofire.on('conflict',   (c) => console.warn('Conflict:', c));
+mongofire.on('error',      (e) => console.error('Error:', e));
+mongofire.on('stopped',    ()  => console.log('Shut down cleanly'));
+```
+
+| Event              | Payload                        | When emitted                           |
+|--------------------|--------------------------------|----------------------------------------|
+| `localReady`       | `Db`                           | Local MongoDB connected (before Atlas) |
+| `ready`            | —                              | `start()` fully completed              |
+| `online`           | —                              | Atlas connected                        |
+| `offline`          | —                              | Atlas becomes unreachable              |
+| `sync`             | `SyncResult`                   | After each sync cycle                  |
+| `conflict`         | `ConflictData`                 | Local write conflicts with remote      |
+| `conflictResolved` | `{ opId, resolution }`         | After retry or dismiss                 |
+| `stopped`          | —                              | `stop()` finished                      |
+| `error`            | `Error`                        | Unexpected sync error                  |
 
 ---
 
-## Using the plugin directly
+## API Reference
 
-If you prefer not to use the MongoFire singleton, import the plugin directly:
+### `startApp(app, port)` → `Promise<http.Server>`
 
-```js
-// Raw Mongoose plugin
-const mongofirePlugin = require('mongofire/plugin');
-UserSchema.plugin(mongofirePlugin, { collection: 'users', ownerField: 'userId' });
+Replaces `app.listen()`. Waits for local DB, then opens the server port. Exits with code 1 on DB failure.
 
-// Or use the factory helper (same signature as mongofire.plugin())
-const { factory } = require('mongofire/plugin');
-UserSchema.plugin(factory('users', { ownerField: 'userId' }));
+```js
+import { startApp } from './mongofire.js';
+startApp(app, process.env.PORT || 3000);
 ```
 
----
+### `plugin(collectionName, options?)` → Mongoose plugin function
 
-## Real-Time Sync
+Attaches change-tracking to a schema. Apply **before** `mongoose.model()`.
+
+```js
+import { plugin } from '../mongofire.js';
+UserSchema.plugin(plugin('users'));
+UserSchema.plugin(plugin('users', { ownerField: 'userId' }));  // multi-tenant
+```
 
-Enable instant sync via MongoDB Atlas Change Streams:
+### `localReady` → `Promise<Db>`
+
+Resolves as soon as local MongoDB is connected, before Atlas.
 
 ```js
-await mongofire.start({
-  // ...
-  realtime: true,   // requires Atlas cluster or local replica set
-});
+import { localReady } from './mongofire.js';
+await localReady;  // DB is guaranteed ready after this
 ```
 
-If Change Streams are unavailable, MongoFire automatically falls back to polling — no crash, no config needed.
+### `ready` → `Promise<MongoFire>`
+
+Resolves after Atlas connect and the first sync.
+
+### `mongofire.sync(type?)` → `Promise<SyncResult>`
+
+Manually trigger a sync (`'required'` or `'all'`).
+
+### `mongofire.status()` → `Promise<SyncStatus>`
+
+Returns `{ online, pending, creates, updates, deletes, realtime }`.
+
+### `mongofire.conflicts()` / `retryConflict(opId)` / `dismissConflict(opId)`
+
+View and resolve sync conflicts.
+
+### `mongofire.reconcile(opts?)` → `Promise<ReconcileResult[]>`
+
+Scan for and recover writes lost in a crash.
+
+### `mongofire.resetLocal()` → `Promise<{ dropped: number }>`
+
+Wipe the local DB. Next startup re-bootstraps from Atlas. **Unsynced changes are lost.**
+
+### `mongofire.stop(timeoutMs?)` → `Promise<void>`
+
+Flush in-flight ops and close connections. Called automatically on `SIGINT`/`SIGTERM`.
 
 ---
 
-## Multi-Tenant Usage
+## Real-Time Sync
 
 ```js
-// Sync only data belonging to a specific user
-await mongofire.start({
-  collections: ['notes', 'tasks'],
-  syncOwner: () => currentUser.id,  // dynamic — re-evaluated on each sync cycle
-  // ...
-});
+// mongofire.config.js
+export default {
+  atlasUri:     process.env.ATLAS_URI,
+  collections:  ['orders'],
+  realtime:     true,    // requires Atlas M10+ or a local replica set
+  syncInterval: 5000,    // polling fallback
+};
 ```
 
-> **Note:** If `syncOwner` throws, the sync is **aborted** and an `error` event is emitted. This prevents unintended access to other users' data.
+Falls back to polling if Change Streams are unavailable. Saves a resume token — restarts pick up exactly where they left off. Restarts use exponential backoff (2 s → 60 s).
 
 ---
 
-## CLI
+## Multi-Tenant
 
-```bash
-# Create config files in current project
-npx mongofire init
+For apps where each user must only sync their own data:
 
-# Force overwrite existing config
-npx mongofire init --force
+```js
+// mongofire.config.js
+export default {
+  collections: ['notes'],
+  syncOwner: () => currentUserId,  // returns the current user's ID
+};
+```
 
-# Check pending sync status
-npx mongofire status
+```js
+// model
+NoteSchema.plugin(plugin('notes', { ownerField: 'userId' }));
+```
 
-# Delete old sync records
-npx mongofire clean
-npx mongofire clean --days=7
+```js
+// create — always set the owner field
+await Note.create({ title: 'My note', userId: req.user._id });
 ```
 
 ---
 
-## TypeScript
+## CLI Reference
 
-Full TypeScript support is included:
+```bash
+npx mongofire init                          # Setup wizard (creates mongofire.js, config, .env)
+npx mongofire init --force                  # Overwrite existing files
+npx mongofire init --esm                    # Force ESM output
+npx mongofire init --cjs                    # Force CJS output
+npx mongofire config                        # Update config interactively
+npx mongofire status                        # Show pending sync counts
+npx mongofire clean --days=7                # Delete records older than 7 days
+npx mongofire conflicts                     # View and resolve conflicts
+npx mongofire reconcile                     # Recover writes lost from crashes
+npx mongofire reconcile --collection=users  # Single collection
+npx mongofire reset-local                   # Wipe local DB and re-bootstrap
+```
 
-```ts
-import mongofire, { MongoFire, SyncConfig, SyncResult, ConflictData } from 'mongofire';
+> Set `MONGOFIRE_DEBUG=1` for full error stack traces.
 
-const config: SyncConfig = {
-  collections: ['users'],
-  atlasUri: process.env.ATLAS_URI,
-  realtime: true,
-};
+---
 
-await mongofire.start(config);
+## TypeScript
 
-mongofire.on('sync', (result: SyncResult) => {
-  console.log(`Uploaded: ${result.uploaded}, Downloaded: ${result.downloaded}`);
-});
+```ts
+import { startApp, plugin, mongofire } from './mongofire.js';
+import type { SyncResult, ConflictData } from 'mongofire';
+
+UserSchema.plugin(plugin('users'));
+startApp(app, 3000);
 
-mongofire.on('conflict', (data: ConflictData) => {
-  console.warn(`Conflict on ${data.collection}/${data.docId}`);
+mongofire.on('sync', (result: SyncResult) => {
+  console.log(`↑${result.uploaded} ↓${result.downloaded}`);
 });
 ```
 
 ---
 
-## How it Works
+## Environment Variables
 
-1. **Change Tracking** — Every `save`/`update`/`delete` via Mongoose hooks is recorded locally before syncing to Atlas
-2. **Upload** — Pending local changes are uploaded to Atlas inside MongoDB transactions, with automatic retry and idempotency
-3. **Download (Bootstrap)** — First sync streams all remote docs in batches. Resumable — a crash mid-bootstrap picks up from where it left off
-4. **Download (Delta)** — Subsequent syncs fetch only changes newer than the last seen position, with no gaps even at millisecond boundaries
-5. **Conflict Resolution** — Version number → timestamp → deviceId tiebreaker (deterministic, no coin flip)
-6. **Offline** — All reads/writes work locally. Changes queue up and upload automatically when Atlas reconnects
+| Variable                           | Default                  | Description                                          |
+|------------------------------------|--------------------------|------------------------------------------------------|
+| `ATLAS_URI`                        | —                        | MongoDB Atlas connection string                      |
+| `LOCAL_URI`                        | `mongodb://127.0.0.1:27017` | Local MongoDB URI                                 |
+| `DB_NAME`                          | `myapp`                  | Database name                                        |
+| `MONGOFIRE_DEBUG`                  | unset                    | Set to `1` for full stack traces                     |
+| `MONGOFIRE_VERIFY_REMOTE`          | `0`                      | Set to `1` to checksum-verify each uploaded document |
+| `MONGOFIRE_COLLECTION_CONCURRENCY` | `4`                      | Collections synced in parallel (max 32)              |
+| `MONGOFIRE_DBPATH`                 | `~/.mongofire/<dbName>`  | Data directory for auto-spawned mongod               |
 
 ---
 
-## Collection Name Rules
+## Troubleshooting
 
-Collection names passed to `mongofire.plugin()` and `config.collections` must:
-- Start with a letter or digit
-- Contain only letters, digits, underscores (`_`), hyphens (`-`), or dots (`.`)
-- **Not** contain a colon (`:`)
-- **Not** start with `_mf_` (reserved for MongoFire internal use)
+### `ERR_MODULE_NOT_FOUND: Cannot find package 'mongofire'`
 
-Invalid names throw a clear error at startup.
+You are importing `from 'mongofire'` instead of `from './mongofire.js'`.
 
----
+```js
+// ❌ Wrong
+import { plugin } from 'mongofire';
 
-## Environment Variables
+// ✅ Correct (from project root)
+import { plugin } from './mongofire.js';
+
+// ✅ Correct (from models/ folder)
+import { plugin } from '../mongofire.js';
+```
+
+### `mongoose.connect() should not be called`
+
+Remove any `mongoose.connect()` calls from your code. MongoFire manages the connection through `localUri` in `mongofire.config.js`.
+
+### `Local MongoDB failed to connect`
+
+- MongoDB is not installed — [download here](https://www.mongodb.com/try/download/community)
+- `mongod` is not in your system PATH
+- `LOCAL_URI` in `.env` is incorrect
+- Port 27017 is blocked by a firewall
+
+MongoFire tries to auto-spawn `mongod`. Set `MONGOFIRE_DBPATH` to a writable directory if the default fails.
+
+### `Cannot find module './mongofire.config.js'`
 
-| Variable | Default | Description |
-|---|---|---|
-| `MONGOFIRE_VERIFY_REMOTE` | `0` | Set to `1` to verify each uploaded doc with a checksum round-trip |
-| `MONGOFIRE_COLLECTION_CONCURRENCY` | `4` | Number of collections synced in parallel |
+Run `npx mongofire init` to regenerate the config file.
 
 ---