Find & Join in Mongo and PostgreSQL

Find & Join Feature in MongoDB and PostgreSQL.md

@@ -0,0 +1,153 @@
+## 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](https://apimaker.dev/find-and-join)
+
+## 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](https://docs.apimaker.dev/v1/docs/schema/schema.html)
+
+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:
+```typescript
+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:** 
+```http
+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:**
+```http
+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](https://docs.apimaker.dev/v1/docs/apis-all/generated-apis/auto-generated-get-all-api.html) and [schema-based REST APIs](https://docs.apimaker.dev/v1/docs/apis-all/schema-apis/auto-generated-schema-based-get-all-api.html) available on the [API Maker Docs Page](https://docs.apimaker.dev/).
+## 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.