替代Git Submodules：Angular汽车项目多仓库依赖如何配置？

Hey there! I totally get why you're ditching Git submodules—they can get messy fast, especially when you're managing multiple custom car projects alongside a shared core repo. Let's walk through the best alternatives tailored to your Angular setup:

1. Git Subtrees (Git Built-In, No Extra Tools) #

This is my go-to for cases where you want the core code to live directly in your custom repos without the submodule hassle. Here's how it works:

• Add the core repo as a subtree in your custom repo (e.g., putting core code in a src/core directory):

  git subtree add --prefix=src/core https://your-main-core-repo-url main --squash
  

  The --squash flag keeps your commit history clean by merging core changes into a single commit.
• Update core code later when there's new changes in the main repo:

  git subtree pull --prefix=src/core https://your-main-core-repo-url main --squash
  

• Push changes back to the core repo if you fix a bug in the core code from a custom project:

  git subtree push --prefix=src/core https://your-main-core-repo-url main
  

Pros: No extra dependencies, core code looks like regular files in your custom repo, easy to debug.
Best for: Small to medium number of custom projects, occasional core updates.

2. Monorepo with Angular Workspaces (NX or Lerna) #

Since you're using Angular, leaning into the monorepo pattern with workspace tools is a fantastic long-term solution. Here's how to set it up:

• Create a root monorepo, then split your code into two types of packages:
  • A shared core package (e.g., @car-app/core) containing all reusable Angular components, services, and logic.
  • Individual custom packages (e.g., @car-app/blue-leather, @car-app/red-20inch) that only hold the差异化 content (paint configs, interior assets, component overrides).
• In each custom package's package.json, add a dependency on your core package:

  "dependencies": {
    "@car-app/core": "workspace:*"
  }
  

• Use tools like NX to handle shared builds, tests, and schematics—NX is purpose-built for Angular monorepos and will save you tons of time on configuration.

Pros: Seamless integration with Angular's toolchain, easy to share code across projects, clear dependency management.
Best for: Scaling to many custom projects, frequent updates to both core and custom code.

3. Git Merge/Rebase Strategy (Simple, No Fancy Tools) #

If you only have a handful of custom repos, a straightforward merge/rebase workflow might be all you need:

• In each custom repo, add the main core repo as a remote:

  git remote add core https://your-main-core-repo-url
  

• Pull the core code into a dedicated branch (e.g., core-upstream):

  git fetch core
  git checkout -b core-upstream core/main
  

• Merge or rebase your custom branch onto the core branch to combine changes:

  # Merge approach
  git checkout main
  git merge core-upstream
  
  # Rebase approach (keeps commit history linear)
  git checkout main
  git rebase core-upstream
  

Just resolve any conflicts as they come, and commit the combined code.

Pros: Dead simple, no learning curve for basic Git users.
Best for: Small number of custom projects, infrequent core updates.

4. Docker Multi-Stage Builds (Deployment-Focused) #

If you want to keep development separate but automate the integration at deploy time, Docker multi-stage builds work great:

1. First, build your core Angular app in a Docker stage:

   FROM node:20 as core-build
   WORKDIR /app/core
   COPY core-repo/package*.json .
   RUN npm install
   COPY core-repo/ .
   RUN ng build --prod
   

2. Then, build your custom app and copy the core build artifacts into it:

   FROM node:20 as custom-build
   WORKDIR /app/custom
   COPY custom-repo/package*.json .
   RUN npm install
   COPY custom-repo/ .
   # Copy core build into custom app's dist folder
   COPY --from=core-build /app/core/dist ./dist/core
   RUN ng build --prod
   

3. Finally, serve the combined build from a lightweight nginx image.

Pros: Keeps dev repos separate, automates integration for deployment.
Best for: When you want to isolate development workflows but need a unified build for production.

Which One Should You Pick? #

• For simplicity with Git alone: Go with Git Subtrees.
• For long-term Angular scalability: Monorepo with NX is the way to go.
• For a tiny number of projects: Merge/Rebase will get the job done.
• For deployment-only integration: Docker Multi-Stage Builds.

内容的提问来源于stack exchange，提问作者Scott