Merging separate Git repositories into a single combined repository is a common need for developers. For example, you may have a frontend and backend repository that are part of the same overall application, but kept in separate repositories during initial development.
Bringing these components together into a single repository makes it easier to view, manage, and work with the full codebase as a unified project. However, preserving the commit history and being able to trace code changes back to their original repository is also important.
The Problem
So, your current setup looks like this:
You've got separate Git repositories for frontend and backend, and now you want to make the Parent Folder the main repository housing both, all while preserving commit histories. Sounds like a plan! Let's dive into the solution.
Steps to Solve
1. Create a New Repository
First things first, let's create a new repository on GitHub (or your preferred hosting service). This will be the main repository for your combined project.
git clone https://github.com/your-username/combined-repo.git
cd combined-repo
# OR In case of offline
git init combined-repo
git remote add origin https://github.com/your-username/combined-repo
Replace "your-username" and "combined-repo" with your GitHub username and the new repository's name. This allows you to pull commits from the source repositories using the remote names as references.
2. Add Remotes
Now, add remotes for both "frontend" and "backend" repositories:
git remote add frontend /path/to/frontend
git remote add backend /path/to/backend
Replace /path/to/frontend and /path/to/backend with the actual paths to your frontend and backend repositories, whether they are offline or online.
3. Fetch Commits
Fetch the commits from both repositories:
git fetch frontend
git fetch backend
This pulls the branches and associated commits into your local repository without actually merging anything.
With the commits fetched, you can start merging each repository one at a time.
4. Merge Frontend
Create and switch to a new branch for frontend:
First, make a branch for each incoming repository:
git checkout -b frontend-merge frontend/master
Now merge the branch while allowing unrelated histories between the new repo and old repos:
git merge --allow-unrelated-histories FETCH_HEAD
The --allow-unrelated-histories flag is crucial to allow merging branches that do not share a common starting commit.
Next, create directories for the frontend, and move the files accordingly from the merged branches:
mkdir frontend
git ls-tree -z --name-only HEAD | xargs -0 -I {} git mv {} frontend/
git commit -m "Merge frontend repository into combined-repo"
Commit to each step. Keeping the code organized this way keeps things isolated during additional merging later.
5. Repeat for Backend
Repeat the process for the backend repository:
git checkout -b backend-merge backend/master
git merge --allow-unrelated-histories FETCH_HEAD
mkdir backend
git ls-tree -z --name-only HEAD | xargs -0 -I {} git mv {} backend/
git commit -m "Merge backend repository into combined-repo"
6. Merge and Resolve Conflicts
Now, let's bring it all together:
git checkout master
git merge frontend-merge
git merge backend-merge
As files are brought together from different repositories, merge conflicts can happen just like during normal development.
Code changes from different sources may modify the same parts of a file in incompatible ways. When this happens, Git stops the merge and flags the conflict.
If you encounter a "refusing to merge unrelated histories" error, use the following:
git merge --allow-unrelated-histories frontend-merge
git merge --allow-unrelated-histories backend-merge
Resolve any merge conflicts if they occur. Commit the changes:
git commit -m "Merge frontend-merge and backend-merge into master"
git push origin master
And there you have it! Your GitHub repository's master branch should now contain the combined content and commit history from both frontend and backend repositories.
Top comments (0)