chore: add bun to CI matrix

[ymc9]

Summary by CodeRabbit

• Tests

  • Expanded automated test coverage to run on both Node.js 20.x and Bun 1.x.
  • Introduced separate, runtime-specific test steps to validate compatibility across environments.

• Chores

  • Updated CI configuration to set a fixed Node.js version (20.x) and add Bun setup.
  • Adjusted workflow to conditionally configure environments based on selected runtime, improving pipeline reliability.

[coderabbitai]

Warning

Rate limit exceeded

@ymc9 has exceeded the limit for the number of commits or files that can be reviewed per hour. Please wait 11 minutes and 42 seconds before requesting another review.

⌛ How to resolve this issue?

After the wait time has elapsed, a review can be triggered using the @coderabbitai review command as a PR comment. Alternatively, push new commits to this PR.

We recommend that you space out your commits to avoid hitting the rate limit.

🚦 How do rate limits work?

CodeRabbit enforces hourly rate limits for each developer per organization.

Our paid plans have higher rate limits than the trial, open-source and free plans. In all cases, we re-allow further reviews after a brief timeout.

Please see our FAQ for further information.

📥 Commits

Reviewing files that changed from the base of the PR and between 3e3bc2d and a6b761b.

📒 Files selected for processing (1)

• packages/language/test/utils.ts (1 hunks)

Note

Other AI code review bot(s) detected

CodeRabbit has detected other AI code review bot(s) in this pull request and will avoid duplicating their findings in the review comments. This may lead to a less comprehensive review.

Walkthrough

Adds a runtime matrix (node, bun) to the CI workflow, configures conditional setup and test steps per runtime, sets Node.js to 20.x, installs Bun 1.x, and replaces a single test step with runtime-specific test steps in .github/workflows/build-test.yml.

Changes

Cohort / File(s)	Summary
CI workflow \.github/workflows/build-test.yml	Introduces matrix for runtimes (node, bun); adds conditional setup for Node 20.x and Bun 1.x; splits tests into runtime-specific steps; updates workflow to run tests with npm for node and bun for bun.

Estimated code review effort

🎯 2 (Simple) | ⏱️ ~10 minutes

Poem

A bunny taps the pipeline drum,
Node hops in, Bun soon comes.
Two paths, one burrow, tests align,
20.x and 1.x rhyme.
CI fields are freshly spun—
green clovers bloom for Node and Bun. 🐇✨

Pre-merge checks and finishing touches

✅ Passed checks (3 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title Check	✅ Passed	The title "chore: add bun to CI matrix" succinctly and accurately summarizes the primary change in the PR — adding Bun as a CI runtime. It is concise, uses a conventional commit prefix, and is specific enough for a teammate scanning history to understand the main intent. It does not include unnecessary noise or irrelevant details.
Docstring Coverage	✅ Passed	No functions found in the changes. Docstring coverage check skipped.

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[claude]

Claude finished @ymc9's task —— View job

---

PR Review: Add Bun to CI Matrix

I've completed my review of the changes that add Bun runtime support to the CI workflow.

Todo List:

• Read and analyze the workflow file changes
• Evaluate CI matrix configuration and best practices
• Check Bun integration approach for potential issues
• Provide comprehensive review feedback

---

Review Feedback

✅ Code Quality & Best Practices

The implementation is well-structured and follows GitHub Actions best practices:

• Clean matrix strategy: The transition from a single node-version to a runtime matrix (.github/workflows/build-test.yml:36) is well-designed and maintains the existing PostgreSQL/SQLite provider matrix
• Conditional setup steps: Proper use of conditional steps for Node.js (lines 48-53) and Bun (lines 55-59) runtime setup
• Consistent command usage: Smart approach using pnpm for dependency management while leveraging bun run test for Bun-specific test execution (line 92)

⚠️ Issues & Recommendations

1. Version Pinning (Security & Stability)

Issue: Using bun-version: latest (line 59) creates unpredictable builds

# Current - problematic
bun-version: latest

# Recommended
bun-version: 1.x  # or specific version like 1.1.34

Impact: CI builds could break unexpectedly when new Bun versions are released

2. Cache Strategy Limitation

Issue: The pnpm cache setup (lines 61-73) may not be optimal for Bun

• Bun has its own package resolution and caching mechanisms
• The current cache only covers pnpm store, not Bun's cache

Recommendation: Consider adding Bun-specific caching:

- name: Setup Bun cache
  if: matrix.runtime == 'bun'
  uses: buildjet/cache@v3
  with:
    path: ~/.bun/install/cache
    key: ${{ runner.os }}-bun-${{ hashFiles('**/bun.lockb', '**/package.json') }}

3. Test Framework Compatibility

Observation: The switch from pnpm run test to bun run test (lines 87-92) looks correct

• Vitest is designed to work with Bun natively
• The TEST_DB_PROVIDER environment variable approach is maintained consistently

🔒 Security Considerations

• Low risk: No security concerns identified
• Using official GitHub Actions (oven-sh/setup-bun@v2) from trusted sources
• Environment variables and secrets handling remains unchanged

⚡ Performance Considerations

Positive impacts:

• Bun's faster package installation should reduce CI times
• Parallel runtime testing provides good coverage without significantly increasing total CI duration

Potential concern:

• CI job count doubles (2 runtimes × 2 providers = 4 jobs vs. previous 2)
• Monitor for buildjet runner capacity if this becomes an issue

🧪 Test Coverage

Excellent coverage strategy:

• Tests both runtimes against both database providers (SQLite & PostgreSQL)
• Maintains existing test commands and environment variable patterns
• The approach aligns well with ZenStack's multi-database support strategy

📦 Package Manager Integration

Well thought out:

• Keeps pnpm for dependency installation (leveraging existing lockfile)
• Uses Bun only for test execution, avoiding package manager conflicts
• Respects the project's packageManager: "[email protected]" specification

---

Summary

This is a solid implementation that adds valuable Bun runtime testing to the CI pipeline. The main concern is the version pinning issue, which should be addressed before merging.

Recommended changes before merge:

1. Pin Bun version to 1.x instead of latest
2. Consider adding Bun-specific caching for better performance

Optional improvements for future PRs:

• Monitor CI performance and consider Bun cache optimization
• Evaluate if separate Bun lockfile (bun.lockb) would be beneficial

The changes maintain backward compatibility while expanding test coverage, which aligns well with ZenStack's goal of supporting multiple JavaScript runtimes.

---

[Copilot]

Pull Request Overview

This PR adds Bun runtime support to the CI build matrix alongside the existing Node.js runtime, enabling tests to run on both runtimes.

• Replaces single node-version matrix with runtime matrix containing both node and bun
• Adds conditional setup steps for both Node.js and Bun runtimes
• Creates separate test steps for each runtime using their respective package managers

---

_{Tip: Customize your code reviews with copilot-instructions.md. Create the file or learn how to get started.}

[claude]

Claude finished @ymc9's task —— View job

---

PR Review: Add Bun to CI Matrix

I've completed my analysis of the PR that adds Bun runtime support to the CI workflow. Here's my comprehensive review:

Todo List:

• Read and analyze the workflow file changes
• Evaluate CI matrix configuration and best practices
• Check Bun integration approach for potential issues
• Provide comprehensive review feedback

Review Summary

Overall Assessment: This is a well-structured change that properly adds Bun support to the CI matrix. The implementation follows good practices with conditional runtime setup and separate test execution steps.

Detailed Analysis

✅ Code Quality & Best Practices

1. Matrix Strategy: The conversion from single node-version to runtime matrix is clean and logical
2. Conditional Setup: Proper use of if conditions to set up Node.js vs Bun environments
3. Cache Strategy: Maintains pnpm cache configuration which works for both runtimes
4. Version Pinning: Good choice using 1.x for Bun version (stable but gets patch updates)

⚠️ Potential Issues & Considerations

1. Native Dependencies: The project uses better-sqlite3 (line 38 in root package.json), which requires native compilation. Bun's compatibility with native Node.js modules has improved but may still have edge cases.

2. Vitest Compatibility: The project uses Vitest for testing. While Bun has good Vitest support, there may be subtle differences in:

   • Module resolution behavior
   • TypeScript compilation
   • File watching capabilities

3. Build Tool Compatibility: The build uses tsup and tsx extensively. These should work with Bun, but may have different performance characteristics.

4. Database Drivers: The project supports PostgreSQL (pg) and SQLite (better-sqlite3). Bun's compatibility with these drivers should be verified, especially for connection pooling and transaction handling.

🔒 Security Considerations

• Supply Chain: Adding Bun introduces another runtime dependency. The workflow correctly pins to 1.x which provides a good balance of stability and security updates.
• Environment Isolation: The matrix strategy properly isolates runtime environments, preventing cross-contamination.

⚡ Performance Considerations

1. Build Matrix Expansion: This doubles the CI matrix from 2 jobs (sqlite/postgresql) to 4 jobs (node+sqlite, node+postgresql, bun+sqlite, bun+postgresql). This increases CI resource usage and execution time.

2. Bun Performance: Bun should provide faster package installation and potentially faster test execution, which may offset the increased matrix size.

🧪 Test Coverage

• Runtime Parity: Good approach running the same test suite on both runtimes to ensure behavioral consistency
• Database Matrix: Maintains testing against both SQLite and PostgreSQL for each runtime
• Missing: Consider adding a step to compare test outputs between runtimes to catch subtle differences

📋 Recommendations

1. Monitor First Runs: Watch the initial CI runs closely for any Bun-specific failures, especially around:

   • Native module compilation (better-sqlite3)
   • Database connection handling
   • TypeScript compilation differences

2. Consider Failure Strategy: Add fail-fast: false to the matrix strategy to see all runtime/database combinations even if one fails:

   strategy:
       fail-fast: false
       matrix:
           runtime: [node, bun]
           provider: [sqlite, postgresql]

3. Documentation: Update project documentation to mention Bun support and any runtime-specific considerations.

4. Gradual Rollout: Consider initially running Bun jobs as continue-on-error: true until stability is proven.

🎯 Minor Suggestions

1. The CodeRabbit suggestion to avoid latest was good, but 1.x is actually a better choice than a specific version for CI
2. Consider adding a comment explaining the runtime matrix for future maintainers
3. The pnpm cache strategy is well-implemented and should work efficiently with both runtimes

Conclusion

This is a solid implementation that follows CI best practices. The main risk areas are around native dependencies and subtle runtime behavior differences, but the approach of running identical test suites on both runtimes should catch most issues. I recommend proceeding with careful monitoring of the initial runs.

---

[claude]

Claude finished @ymc9's task —— View job

---

PR Review: Add Bun to CI Matrix

I've completed my analysis of the PR that adds Bun runtime support to the CI workflow. Here's my comprehensive review:

Todo List:

• Read and analyze the workflow file changes
• Evaluate CI matrix configuration and best practices
• Check Bun integration approach for potential issues
• Provide comprehensive review feedback

---

Review Feedback

✅ Code Quality & Best Practices

The implementation is well-structured and follows GitHub Actions best practices:

• Clean matrix strategy: The transition from a single node-version to a runtime matrix (.github/workflows/build-test.yml:36) is well-designed and maintains the existing PostgreSQL/SQLite provider matrix
• Conditional setup steps: Proper use of conditional steps for Node.js (lines 48-53) and Bun (lines 55-59) runtime setup
• Consistent command usage: Smart approach using pnpm for dependency management while leveraging bun run test for Bun-specific test execution (line 92)
• Version pinning: Good choice using specific version 1.2.22 instead of latest for reproducible builds

⚠️ Potential Issues & Considerations

1. Native Dependencies Compatibility

Issue: The project uses better-sqlite3 (line 38 in root package.json), which requires native compilation

• Bun's compatibility with native Node.js modules has improved significantly but may still have edge cases
• The onlyBuiltDependencies configuration suggests this was already a consideration

Recommendation: Monitor the first few CI runs closely for native module compilation issues

2. Test Framework Compatibility

Analysis: The project uses Vitest for testing (package.json:10, 33)

• Bun has good Vitest support, but there may be subtle differences in module resolution or TypeScript compilation
• The identical test command approach (bun run test vs pnpm run test) should catch most behavioral differences

3. Cache Strategy Limitation

Observation: The pnpm cache setup (lines 61-73) may not be optimal for Bun

• Bun has its own package resolution and caching mechanisms
• Current cache only covers pnpm store, not Bun's internal cache

Low Priority: Consider adding Bun-specific caching in future iterations for better performance

🔒 Security Considerations

✅ Excellent security practices:

• Uses official GitHub Actions (oven-sh/setup-bun@v2) from trusted sources
• Proper version pinning prevents supply chain attacks via version drift
• Environment variables and secrets handling remains unchanged
• Matrix strategy provides proper environment isolation

⚡ Performance Considerations

Positive impacts:

• Bun's faster package installation and test execution should improve CI times
• Parallel runtime testing provides comprehensive coverage

Considerations:

• CI job count doubles (2 runtimes × 2 providers = 4 jobs vs. previous 2)
• Using buildjet runners should handle the increased load well
• Bun's performance benefits may offset the increased matrix size

🧪 Test Coverage

Excellent strategy:

• Tests both runtimes against both database providers (SQLite & PostgreSQL)
• Maintains identical test commands and environment variable patterns
• The approach will catch runtime-specific behavioral differences
• Aligns well with ZenStack's multi-database support strategy

📦 Implementation Quality

Well thought out:

• Keeps pnpm for dependency installation (leveraging existing lockfile and cache)
• Uses Bun only for test execution, avoiding package manager conflicts
• Respects the project's packageManager: "[email protected]" specification
• Maintains all existing build and lint steps consistently

🎯 Minor Suggestions

1. Documentation: Consider updating project README to mention Bun support once proven stable
2. Failure Strategy: Consider adding fail-fast: false to see all runtime/database combinations:

   strategy:
       fail-fast: false  # See all combinations even if one fails
       matrix:
           runtime: [node, bun]
           provider: [sqlite, postgresql]

3. Monitoring: Watch for any differences in error messages or test timing between runtimes

📋 Risk Assessment

Low Risk Areas:

• CI workflow structure and syntax
• Environment setup and caching
• Security and permissions

Medium Risk Areas:

• Native dependency compilation (better-sqlite3)
• Potential subtle runtime behavior differences
• Test framework integration edge cases

Mitigation: The matrix strategy running identical tests on both runtimes should catch most issues quickly

---

Summary

This is a solid, well-implemented change that adds valuable Bun runtime testing to the CI pipeline. The implementation follows best practices and should provide good coverage of potential runtime-specific issues.

Key strengths:

• Proper version pinning and security practices
• Clean matrix strategy that maintains existing test coverage
• Smart separation of package management (pnpm) and test execution (runtime-specific)
• Comprehensive testing across database providers

Main recommendation: Monitor the initial CI runs closely for any Bun-specific issues, particularly around native module compilation and test behavior consistency.

The changes align well with ZenStack's goal of supporting multiple JavaScript runtimes while maintaining robust testing practices.

---

[coderabbitai]

Actionable comments posted: 1

🧹 Nitpick comments (1)

.github/workflows/build-test.yml (1)

35-38: Matrix looks good; consider avoiding unnecessary Postgres for sqlite runs.

Right now the Postgres service starts for all matrix entries, including provider: sqlite, wasting minutes. Consider splitting into two jobs or using separate workflows so Postgres only runs for postgresql.

I can draft an include/exclude matrix or a split‑job version if you want.

📜 Review details

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between f9baaaf and 3e3bc2d.

📒 Files selected for processing (1)

• .github/workflows/build-test.yml (3 hunks)

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (4)

• GitHub Check: build-test (bun, postgresql)
• GitHub Check: build-test (node, sqlite)
• GitHub Check: build-test (bun, sqlite)
• GitHub Check: build-test (node, postgresql)

🔇 Additional comments (3)

.github/workflows/build-test.yml (3)

55-60: Prefer a major-range (1.x) for Bun unless you need to pin exactly.

Pinning to 1.2.22 is reproducible but increases maintenance. If you only need Bun 1, use 1.x to automatically receive patches/minors; otherwise keep exact and ensure Renovate/Dependabot bumps it.

Proposed change:

-                  bun-version: 1.2.22
+                  bun-version: 1.x

---

86-89: Node test path LGTM.

---

90-93: Verify Bun test path works with your current scripts and deps.

• bun run test will run the package script under Bun; confirm your test runner and dependencies are compatible with Bun (e.g., Vitest/Jest under Bun, pg driver for Postgres).
• If tests rely on Node‑only features, consider TEST_RUNTIME=bun gating inside scripts or using bun test only if you’ve migrated to Bun’s test runner.

I can help adjust scripts or add a quick detector to skip Bun‑incompatible suites.

[claude]

Claude finished @ymc9's task —— View job

---

PR Review: Add Bun to CI Matrix

I've completed my analysis of the PR that adds Bun runtime support to the CI workflow. Here's my comprehensive review:

Todo List:

• Read and analyze the workflow file changes
• Evaluate CI matrix configuration and best practices
• Check Bun integration approach for potential issues
• Provide comprehensive review feedback

---

Review Feedback

✅ Code Quality & Best Practices

The implementation is well-structured and follows GitHub Actions best practices:

• Clean matrix strategy: The transition from a single node-version to a runtime matrix (.github/workflows/build-test.yml:36) is well-designed and maintains the existing PostgreSQL/SQLite provider matrix
• Conditional setup steps: Proper use of conditional steps for Node.js (lines 48-53) and Bun (lines 55-59) runtime setup
• Consistent command usage: Smart approach using pnpm for dependency management while leveraging bun run test for Bun-specific test execution (line 92)
• Version pinning: Good choice using specific version 1.2.22 instead of latest for reproducible builds

⚠️ Critical Issue Identified

Node.js Dependency Problem

Issue: The workflow only installs Node.js when matrix.runtime == 'node' (line 49), but the build process requires Node.js for ALL runtime jobs:

• pnpm requires Node.js to function (line 76)
• tsx command requires Node.js (line 81)
• Build and lint steps will fail on Bun jobs without Node.js available

Impact: Bun matrix jobs will likely fail during dependency installation or build steps

Fix Required: Remove the conditional from Node.js setup so it runs for all matrix combinations:

- name: Setup Node.js 20.x (needed for pnpm/tsx in all runs)
  uses: buildjet/setup-node@v3
  with:
    node-version: 20.x
    cache: 'pnpm'

⚠️ Potential Issues & Considerations

1. Native Dependencies Compatibility

Issue: The project uses better-sqlite3 (package.json:38), which requires native compilation

• Bun's compatibility with native Node.js modules has improved but may still have edge cases
• The onlyBuiltDependencies configuration suggests this was already a consideration

Recommendation: Monitor the first few CI runs closely for native module compilation issues

2. Test Framework Compatibility

Analysis: The project uses Vitest for testing (package.json:10, 33)

• Bun has good Vitest support, but there may be subtle differences in module resolution or TypeScript compilation
• The identical test command approach (bun run test vs pnpm run test) should catch most behavioral differences

3. Cache Strategy Limitation

Observation: The pnpm cache setup (lines 61-73) may not be optimal for Bun

• Bun has its own package resolution and caching mechanisms
• Current cache only covers pnpm store, not Bun's internal cache

Low Priority: Consider adding Bun-specific caching in future iterations for better performance

🔒 Security Considerations

✅ Excellent security practices:

• Uses official GitHub Actions (oven-sh/setup-bun@v2) from trusted sources
• Proper version pinning prevents supply chain attacks via version drift
• Environment variables and secrets handling remains unchanged
• Matrix strategy provides proper environment isolation

⚡ Performance Considerations

Positive impacts:

• Bun's faster package installation and test execution should improve CI times
• Parallel runtime testing provides comprehensive coverage

Considerations:

• CI job count doubles (2 runtimes × 2 providers = 4 jobs vs. previous 2)
• Using buildjet runners should handle the increased load well
• Bun's performance benefits may offset the increased matrix size

🧪 Test Coverage

Excellent strategy:

• Tests both runtimes against both database providers (SQLite & PostgreSQL)
• Maintains identical test commands and environment variable patterns
• The approach will catch runtime-specific behavioral differences
• Aligns well with ZenStack's multi-database support strategy

📦 Implementation Quality

Well thought out:

• Keeps pnpm for dependency installation (leveraging existing lockfile and cache)
• Uses Bun only for test execution, avoiding package manager conflicts
• Respects the project's packageManager: "[email protected]" specification
• Maintains all existing build and lint steps consistently

🎯 Minor Suggestions

1. Documentation: Consider updating project README to mention Bun support once proven stable
2. Failure Strategy: Consider adding fail-fast: false to see all runtime/database combinations:

   strategy:
       fail-fast: false  # See all combinations even if one fails
       matrix:
           runtime: [node, bun]
           provider: [sqlite, postgresql]

3. Monitoring: Watch for any differences in error messages or test timing between runtimes

📋 Risk Assessment

Low Risk Areas:

• CI workflow structure and syntax
• Environment setup and caching
• Security and permissions

Medium Risk Areas:

• Native dependency compilation (better-sqlite3)
• Potential subtle runtime behavior differences
• Test framework integration edge cases

High Priority Fix:

• CRITICAL: Node.js conditional setup must be removed to prevent Bun job failures

---

Summary

This is a solid, well-implemented change that adds valuable Bun runtime testing to the CI pipeline, but requires one critical fix before merging.

Required change before merge:

• Remove the if: matrix.runtime == 'node' condition from Node.js setup to ensure all jobs have access to Node.js for build tools

Key strengths:

• Proper version pinning and security practices
• Clean matrix strategy that maintains existing test coverage
• Smart separation of package management (pnpm) and test execution (runtime-specific)
• Comprehensive testing across database providers

Main recommendation: After fixing the Node.js conditional issue, monitor the initial CI runs closely for any Bun-specific issues, particularly around native module compilation and test behavior consistency.

The changes align well with ZenStack's goal of supporting multiple JavaScript runtimes while maintaining robust testing practices.

---