如何将Bazel集成到包含多子项目的npm单体仓库中？

Got it, let’s walk through a practical, tailored setup for your monorepo using Bazel—covering all your requirements: dependency-aware builds, Travis CI integration, docs generation, and automated deployments. I’ve worked through similar monorepo Bazel setups, so this should fit neatly with your three projects.

First, let’s align on a clean directory layout that Bazel will understand. This keeps dependencies explicit and easy to manage:

your-monorepo/
├── WORKSPACE          # Bazel workspace config
├── BUILD.bazel        # Root build config
├── core/              # Truffle Solidity project
│   ├── BUILD.bazel
│   ├── truffle-config.js
│   └── contracts/
├── core-js/           # JS library wrapping Core's artifacts
│   ├── BUILD.bazel
│   ├── src/
│   └── package.json
└── muse/              # React/Redux frontend
    ├── BUILD.bazel
    ├── src/
    └── package.json

In your root WORKSPACE, load the core Bazel rules you’ll need (focused on Node.js/Solidity tooling):

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

# Load rules_nodejs for JS/React projects
http_archive(
    name = "rules_nodejs",
    sha256 = "YOUR_RULES_NODEJS_SHA",
    urls = ["https://github.com/bazelbuild/rules_nodejs/releases/download/6.0.0/rules_nodejs-6.0.0.tar.gz"],
)

load("@rules_nodejs//:index.bzl", "node_repositories")
node_repositories(package_json = ["//:package.json"])

# Optional: Load Solidity rules if you want native Bazel Solidity compilation (instead of Truffle)
# http_archive(
#     name = "rules_solc",
#     sha256 = "YOUR_RULES_SOLC_SHA",
#     urls = ["https://github.com/abseil/rules_solc/releases/download/v0.1.0/rules_solc-v0.1.0.tar.gz"],
# )

We’ll define explicit dependencies between projects so Bazel only rebuilds what’s changed.

Core (Truffle Project) #

Since you’re using Truffle, we’ll create a genrule to trigger Truffle compilation and expose artifacts to Core.js:

# core/BUILD.bazel
genrule(
    name = "compile_contracts",
    srcs = glob(["contracts/**/*.sol", "truffle-config.js"]),
    outs = [
        "build/contracts/YourCoreContract.json",
        # List all your compiled artifact JSON files here
    ],
    cmd = """
        cd $(@D)/../ && npx truffle compile --all
        cp -r build/contracts $(@D)/build/contracts
    """,
    tools = ["//:node_modules/truffle"],
)

# Expose artifacts to Core.js
filegroup(
    name = "contract_artifacts",
    srcs = [":compile_contracts"],
    visibility = ["//core-js:__pkg__"],
)

Core.js (JS Library) #

Depend on Core’s artifacts, bundle the library, and prepare it for npm:

# core-js/BUILD.bazel
load("@npm//:defs.bzl", "pkg_npm")
load("@rules_nodejs//:index.bzl", "js_library")

js_library(
    name = "core_js_lib",
    srcs = glob(["src/**/*.js"]),
    deps = [
        "//core:contract_artifacts",
        "@npm//ethers",  # Example: if you use ethers to wrap contracts
    ],
    data = ["//core:contract_artifacts"],
)

# Package for npm deployment
pkg_npm(
    name = "npm_package",
    srcs = [":core_js_lib"],
    package_name = "@your-org/core-js",
    version = "1.0.0",
    visibility = ["//muse:__pkg__", "//visibility:public"],
)

Muse (React/Redux Frontend) #

Depend on Core.js, bundle the app, and set up tests:

# muse/BUILD.bazel
load("@rules_nodejs//react:index.bzl", "react_bundle")
load("@npm//:defs.bzl", "pkg_npm")

react_bundle(
    name = "muse_bundle",
    src = "src/index.js",
    deps = [
        "//core-js:npm_package",
        "@npm//react",
        "@npm//react-dom",
        "@npm//redux",
        "@npm//react-redux",
    ],
)

# Run Jest tests
nodejs_binary(
    name = "test",
    entry_point = "src/test/index.test.js",
    deps = [
        ":muse_bundle",
        "@npm//jest",
        "@npm//@testing-library/react",
    ],
)

Set up .travis.yml to run builds, tests, and deployments with Bazel (use Bazelisk to auto-manage Bazel versions):

language: node_js
node_js: 18
cache:
  directories:
    - "$HOME/.cache/bazel"
    - "$HOME/.npm"
before_install:
  - npm install -g @bazel/bazelisk
script:
  - bazel test //...  # Run all tests across projects
  - bazel build //... # Build all artifacts
  - bazel run //core-js:npm_package.publish  # Deploy Core.js to npm
  - bazel run //muse:deploy  # Run frontend post-deploy tasks
env:
  global:
    - NPM_TOKEN=${{ secrets.NPM_TOKEN }}  # Store your npm token in Travis secrets

Pro tips:

• Enable Bazel caching in Travis to speed up subsequent builds.
• Restrict deployments to only run on main branch pushes using Travis branches config.

Add a genrule to Core.js to generate docs with tools like TypeDoc or JSDoc:

# core-js/BUILD.bazel
genrule(
    name = "generate_docs",
    srcs = glob(["src/**/*.js"]),
    outs = ["docs"],
    cmd = """
        npx typedoc --out $(@D)/docs $(SRCS)
    """,
    tools = ["@npm//typedoc"],
)

You can extend this to deploy docs to GitHub Pages by adding a nodejs_binary that pushes the docs output to your repo’s gh-pages branch.

For npm deployment, configure your WORKSPACE to use your npm token (passed via Travis env):

# WORKSPACE
load("@rules_nodejs//npm:npm_registry.bzl", "npm_registry")

npm_registry(
    name = "npm",
    registry = "https://registry.npmjs.org/",
    token = "$(NPM_TOKEN)",
)

For Muse’s post-deploy tasks (e.g., deploying to Netlify/Vercel), create a custom deployment script:

# muse/BUILD.bazel
nodejs_binary(
    name = "deploy",
    entry_point = "scripts/deploy.js",
    deps = ["@npm//netlify-cli"],
    data = [":muse_bundle"],
)

In scripts/deploy.js, add code to trigger your frontend deployment tool (e.g., netlify deploy --prod --dir=path/to/bazel/bundle).

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