Node.js Developer Guide
Other documentationsDemoCommunityGitHub
  • Forest Admin
  • Getting started
    • How it works
    • Quick start
    • Install
      • Create your agent
      • Expose an HTTP endpoint
        • For standalone agents
        • On Express
        • On Koa
        • On Fastify
        • On NestJS
      • Autocompletion & Typings
      • Troubleshooting
    • Migrating legacy agents
      • What's new
      • Pre-requisites
      • Recommendations
      • Migration steps
        • Run new agent in parallel
        • Configure database connection
        • Code transformations
          • API Charts
          • Live Queries
          • Smart Charts
          • Route overrides
          • Smart Actions
          • Smart Fields
          • Smart Relationships
          • Smart Segments
        • Compare schemas
        • Swap agents
      • Post-migration
        • Dropping Sequelize
        • Optimize your agent
  • Data Sources
    • Getting Started
      • Collection selection
      • Naming conflicts
      • Cross-data source relationships
      • Query interface and Native Queries
        • Fields and projections
        • Filters
        • Aggregations
    • Provided data sources
      • SQL (without ORM)
      • Sequelize
      • Mongoose
      • MongoDB
    • Write your own
      • Replication strategy
        • Persistent cache
        • Updating the replica
          • Scheduled rebuilds
          • Change polling
          • Push & Webhooks
        • Schema & References
        • Write handlers
      • Translation strategy
        • Structure declaration
        • Capabilities declaration
        • Read implementation
        • Write implementation
        • Intra-data source Relationships
      • Contribute
  • Agent customization
    • Getting Started
    • Actions
      • Scope and context
      • Result builder
      • Static Forms
      • Widgets in Forms
      • Dynamic Forms
      • Form layout customization
      • Related data invalidation
    • Charts
      • Value
      • Objective
      • Percentage
      • Distribution
      • Leaderboard
      • Time-based
    • Fields
      • Add fields
      • Move, rename and remove fields
      • Override binary field mode
      • Override writing behavior
      • Override filtering behavior
      • Override sorting behavior
      • Validation
    • Hooks
      • Collection hook
      • Collection override
    • Pagination
    • Plugins
      • Provided plugins
        • AWS S3
        • Advanced Export
        • Flattener
      • Write your own
    • Relationships
      • To a single record
      • To multiple records
      • Computed foreign keys
      • Under the hood
    • Search
    • Segments
  • Frontend customization
    • Smart Charts
      • Create a table chart
      • Create a bar chart
      • Create a cohort chart
      • Create a density map
    • Smart Views
      • Create a Map view
      • Create a Calendar view
      • Create a Shipping view
      • Create a Gallery view
      • Create a custom tinder-like validation view
      • Create a custom moderation view
  • Deploying to production
    • Environments
      • Deploy on AWS
      • Deploy on Heroku
      • Deploy on GCP
      • Deploy on Ubuntu
      • Deploy on Azure
    • Development workflow
    • Using branches
    • Deploying your changes
    • Forest Admin CLI commands
      • init
      • login
      • branch
      • switch
      • set-origin
      • push
      • environments:create
      • environments:reset
      • deploy
  • Under the hood
    • .forestadmin-schema.json
    • Data Model
      • Typing
      • Relationships
    • Security & Privacy
Powered by GitBook
On this page
  • Introspection
  • Flattening
  • Data Navigation

Was this helpful?

  1. Data Sources
  2. Provided data sources

MongoDB

This is the official documentation of the @forestadmin/agent Node.js agent.

The MongoDB data source allows importing collections from a MongoDB datasource, without the need for an ORM like Mongoose

To make everything work as expected, you need to install the package @forestadmin/datasource-mongo.

then, you can declare your datasource like so:

const { createAgent } = require('@forestadmin/agent');
const { createMongoDataSource } = require('@forestadmin/datasource-mongo');

// Create agent and import collections from mongoose.connection
const agent = createAgent(options).addDataSource(
  createMongoDataSource({
    uri: 'mongodb://localhost:27017',
    dataSource: { flattenMode: 'auto' },
  }),
);

Introspection

Unlike other (SQL or ORM) datasources, MongoDB does not necessarily have a defined schema structuring the data. Therefore, at startup the agent analyses a sample of documents that live in your database to determine its structure. This process is called introspection. You are able to control how many samples are taken from your database to perform the introspection

  createMongoDataSource({
    uri: 'mongodb://localhost:27017',
    introspection: {
      collectionSampleSize: 100, // how many documents are sampled per collection
      referenceSampleSize: 10, // how many references are taken to deduce relationships
      maxPropertiesPerObject: 30, // how many properties should be extracted out as columns
    },
    dataSource: { flattenMode: 'auto' },
  }),

Settings those values too high might make your agent slower to startup

If the introspection returns some collections that you do not want to see, you may use the same syntax as for all the other datasources to remove them:

const agent = createAgent(options).addDataSource(
  createMongoDataSource({ uri: connectionString }),
  { exclude: ['accounts', 'accounts_bills', 'accounts_bills_items'] },
);

Flattening

MongoDB stores its data as BSON documents which can be nested. This format looks great on Forest Admin by default, with correct indentation, but you might also want to flatten it into dedicated rows to improve the presentation.

example in manual mode:

const agent = createAgent(options).addDataSource(
  createMongoDataSource({
    uri: connectionString,
    dataSource: {
      flattenMode: 'manual',
      flattenOptions: {
        // name of the Mongoose model
        persons: {
          // paths that should be converted to independent collections
          asModels: ['bills'],

          // paths that should be moved to the root of the collection
          asFields: ['address'],
          // or
          // asFields: ['address.streetName', 'address.city', 'address.country'],
          // or
          // asFields: [{ field: 'address', level: 1 }],
        },
      },
    },
  }),
);

Data Navigation

When customizing your agent, you will need to navigate through your data efficiently. This section explains how to structure paths based on different field types.

Separator Behavior

There are two different separators depending on the field type:

  • Nested Fields (@@@) – Used when accessing a nested field.

  • Related Data (:) – Used when accessing related data.

Example

Consider a User collection with an address relation that contains a city field, which itself has a nested name field.

User (collection) → address (relation) → city (field) → name (nested field)

To access the name field inside city, the path would be:

address:city@@@name

This structure ensures a clear distinction between relationships and nested properties.

PreviousMongooseNextWrite your own

Last updated 2 months ago

Was this helpful?

The datasource-mongo uses the same flattening options as the Forest Admin Mongoose datasource, which means that you can control how your nested models should be flattened using

the same syntax