Migrating from Bubble to Xano | Part 2 - Relationships, Pagination, & Sync

In this comprehensive guide, we'll walk you through the process of setting up a seamless integration between your Bubble and Xano databases. This integration will allow you to maintain a synchronized relationship between the two platforms, ensuring consistent and up-to-date data across your applications.

Prerequisites

Before we begin, make sure you have the following:

1. A Bubble account with an existing database
2. A Xano account with access to the Xano dashboard
3. The necessary API credentials and access keys for both platforms

Part 1: Initial Setup and Data Ingestion

In the first part of this tutorial, we set up a basic synchronization between the Bubble and Xano databases, ingesting all records from the Bubble API response. If you haven't completed this step, refer to the previous guide on setting up the initial data ingestion.

Part 2: Maintaining Relationships

In this section, we'll focus on setting up and maintaining relationships between the Bubble and Xano databases. We'll cover how to handle company and deal relationships, as well as deal with pagination to ensure all records are synchronized.

Step 1: Identify Existing Relationships

First, let's identify the existing relationships in your Bubble database. In our example, we have a company relationship and a deal relationship associated with the customers table.

Inside the Xano customers table, we have corresponding table relationships set up with company_id and deal_id fields.

Step 2: Set Up Conditional Checks for Relationships

To maintain these relationships in Xano, we'll use conditional checks to verify if a relationship exists before adding or updating records. Here's how we'll do it:

1. Create a conditional group within the existing for each loop that iterates over the customers records.
2. Use the get filter to check if the company relationship exists for the current customer record.
3. If the company relationship exists (doesn't equal null), add the record to the companies table in Xano using the add or edit record step.
4. Retrieve the Xano ID of the newly added or existing company record from the output.
5. Repeat steps 2-4 for the deal relationship, adding records to the deals table in Xano.

By following this approach, we ensure that relationships are only created or updated in Xano if they exist in the Bubble data.

Step 3: Handle Pagination

To handle pagination and ensure all records are synchronized, we'll use a while loop instead of a for each loop. Here's how it works:

1. Create a pagination_continue variable and set it to true.
2. Create a cursor_count variable and initialize it to 0.
3. Set up a while loop that continues running as long as pagination_continue is true.
4. Inside the while loop, include the logic for adding customer records and handling relationships (from the previous steps).
5. After processing the current set of records, increment the cursor_count by the number of records processed (e.g., 100).
6. Update the API request URL with the cursor_count parameter to fetch the next set of records.
7. Check if the remaining_record_count from the API response is 0. If so, set pagination_continue to false to stop the loop.

By implementing this pagination logic, you'll be able to fetch and process all records from the Bubble API, regardless of the total number of records.

Step 4: Handle List of Relationships

In some cases, you may have a list of relationships associated with a record. In our example, we have a list_of_deals relationship in the Bubble data. To handle this, follow these steps:

1. Check if the list_of_deals exists and is not null for the current customer record.
2. If it exists, create an empty array to store the Xano IDs of the associated deals.
3. Iterate over the list_of_deals and perform the following for each deal:

• Check if the deal exists in the deals table in Xano using the add or edit record step.
• If the deal doesn't exist, add it to the deals table.
• Retrieve the Xano ID of the deal from the output.
• Add the Xano ID to the array created in step 2.

4. After iterating over all deals, add the array of Xano IDs to the deals_list field in the customers table.

By following these steps, you'll ensure that the list of relationships is properly maintained in the Xano database.

Part 3: Automating the Synchronization Process

Now that we've set up the logic for synchronizing data between Bubble and Xano, it's time to automate the process using Xano's task feature.

1. Navigate to the Tasks section in the Xano dashboard.
2. Create a new task, e.g., "Bubble Customer Sync."
3. In the task configuration, set the desired timing (e.g., daily at a specific time) for the synchronization to occur.
4. Select the function you created in the previous steps from the "Custom Functions" section.
5. Publish and enable the task.

Once enabled, the task will run according to the specified schedule, keeping your Bubble and Xano databases synchronized.

Conclusion

Congratulations! You've successfully set up a seamless integration between your Bubble and Xano databases, maintaining relationships and ensuring consistent data across both platforms. This integration will streamline your development process and provide a solid foundation for building robust applications.

Remember, if you encounter any issues or have suggestions for improvement, feel free to leave a comment or reach out to the community for support. Happy coding!