testrepo/Find & Join Feature in MongoDB and PostgreSQL.md

Query Across SQL and NoSQL — Without Writing Code

MongoDB and PostgreSQL are often used together in modern applications — each bringing unique strengths. While PostgreSQL offers structured, relational storage, MongoDB gives flexibility through document-based collections.

But combining data from both in real time has always been a challenge. Traditionally, you’d have to:

• Write custom backend logic to merge data
• Create multiple API calls or aggregation pipelines
• Maintain sync through fragile ETL workflows

To solve this challenge, API Maker introduces the Find & Join feature.

Why Use Find & Join for MongoDB and PostgreSQL

Modern applications often use a polyglot database architecture — leveraging MongoDB for unstructured or flexible data and PostgreSQL for structured, relational data.

While this separation is practical from a design and performance standpoint, it introduces a major challenge:

How do you fetch connected data across MongoDB and PostgreSQL in a single query — without building and maintaining complex backend logic?

This is exactly where API Maker’s Find & Join feature shines.

It allows you to perform deep, cross-database joins and filters between MongoDB and PostgreSQL using a single, declarative JSON query — all through REST APIs.

This page provides information on using the Find & Join feature specifically with MongoDB and PostgreSQL.

If you're looking for a general overview of the Find & Join feature, please refer to the - Find & Join Feature

Schema Setup in Api Maker

To enable Find & Join operations between MongoDB and PostgreSQL, you need to define relationships in your table/collection schema using API Maker’s Table schema.

For a Detailed Information about the Schema Setup, you can refer to this page - Schema Setup

Once the schema is defined, API Maker can automatically resolve joins at runtime — even across different database types.

Defining the Relationship in Schema

Let’s say:

• You have a users table in PostgreSQL
• You have a profiles collection in MongoDB

You want to use an API that supports the Find & Join feature on the profiles collection (MongoDB). In this case, you'd define the relationship like this:

user_id: <ISchemaProperty>{
    __type: EType.number,
    instance: "Postgres",
    database: "accounts_db",
	table: "users",
	column: "id"
}

Here what each field means:

• __type: EType.number : Indicates that the user_id field is a number (to match the PostgreSQL id column type).
• instance: "Postgres" : Specifies the target database engine — in this case, PostgreSQL.
• database: "accounts_db" : The name of the PostgreSQL database where the users table resides.
• table: "users" : The relational table in PostgreSQL to which the user_id field will be linked.
• column: "id" : The specific column in the users table that the user_id field refers to.

With this schema defined, API Maker can:

• Automatically recognize and resolve the relationship between MongoDB and PostgreSQL
• Enable join queries like user_id.name directly in your REST API calls
• Eliminate the need for custom backend join logic — it's all handled for you at runtime

Sample Query Examples :

Once you've defined relationships between your MongoDB collections and PostgreSQL tables in the schema, you can use the Find & Join feature directly in your API calls — without writing any backend logic.

API Maker supports the Find & Join Feature in both the :

• GET requests (using URL query parameters)
• POST requests (using request body for advanced querying)

Example Scenario

You have:

• A users table in PostgreSQL
• A profiles collection in MongoDB with a field user_id referencing users.id

1. GET API Example (Using URL Query Parameter) : Use the find Query parameter in your auto-generated GET API to filter across relationships.

Request:

GET /api/profiles?find={ "user_id.name": "Alice" }

This query fetches all profiles (from MongoDB) where the related user (from PostgreSQL) has the name "Alice".

2. POST API Example : POST APIs give you more flexibility — allowing you to send a find object along with additional options like sort, limit, and deep.

Request:

POST /api/query/profiles
Content-Type: application/json

{
  "find": {
    "user_id.signup_date": { "$gt": "2024-01-01" },
    "user_id.role": "admin"
  },
  "limit": 10,
  "sort": {
    "user_id.signup_date": -1
  }
}

This will return up to 10 profiles linked to PostgreSQL users who signed up after January 1st, 2024 and have the role "admin" — sorted by most recent signup.

To explore all REST APIs that support Find & Join, check out the auto-generated REST APIs and schema-based REST APIs available on the API Maker Docs Page.

Comparison to Traditional Methods & Other Platforms

Joining data between MongoDB and PostgreSQL has traditionally been a complex, manual process for developers.

Traditional Methods: Before tools like API Maker, developers had to:

• Write custom backend code to connect and query both databases
• Manually merge results at the application level
• Build and maintain fragile ETL pipelines
• Handle sync issues and performance bottlenecks

These methods are time-consuming and hard to scale — especially when relationships become more complex.

How API Maker Simplifies Cross Database Joins and Conditional Filtering :

• No backend logic required
• Schema-based joins resolved automatically at runtime
• Real-time querying across different databases
• Simple REST API interface — easy to use from frontend or backend

Compared to Other Platforms

Feature	API Maker	Appwrite	Supabase	Firebase
Cross-DB Joins (Mongo + SQL)	Yes	No	No	No
N-Level Nested Joins	Unlimited	No	Basic	No
REST Support for Join Queries	Full	Partial	Yes	Firestore only
Schema-Based Join Logic	Yes	No	Limited	No
Works with Mongo + PostgreSQL	Yes	No	No	No

API Maker is the only platform among these that offers real-time, schema-aware, cross database joins between MongoDB and PostgreSQL — with no backend logic required.

FAQ's

1. Can I join MongoDB collections with PostgreSQL tables in both directions? Yes. As long as the relationship is defined in your schema, you can perform joins in either direction — MongoDB → PostgreSQL or PostgreSQL → MongoDB — using the same query structure.

2. How do I filter on PostgreSQL fields from within a MongoDB collection? You can use nested dot notation based on your schema definition. For example: { "user_id.role": "admin" }. In this case, user_id is a reference from the MongoDB profiles collection to the PostgreSQL users table.

3. Is performance impacted by cross-database joins? API Maker optimizes cross-database joins at runtime. For best performance, make sure to index the join keys in both MongoDB and PostgreSQL.