Google Summer of Code 2025 with AsyncAPI - Project Report

GSoC 2025: AsyncAPI Generator Maintainership.md

Google Summer of Code 2025 Final Report

Mentee: Adi Boghawala
Mentor: Lukasz Gornicki
Organization: AsyncAPI
Project Title: AsyncAPI Generator Maintainership
Repository: AsyncAPI Generator

Project Summary

My GSoC project focused on taking maintainership of the AsyncAPI Generator. Rather than focusing on a single feature, this project was about learning what it truly means to be a maintainer — triaging issues, fixing bugs, reviewing PRs, writing tests, improving documentation, mentoring newcomers, and shaping the project’s long-term direction. This hands-on experience provided both technical depth and community leadership skills, offering a complete view of open-source maintainership and its impact on project growth.

Contributions

This project was all about maintainership, so my role naturally went far beyond just writing code. I found myself involved in the full spectrum of open-source practices, from community support to process improvements. Here’s a closer look at what I contributed:

Writing Code

1. Unified Integration Testing for WebSocket Clients
   • Problem: More than 80% of the integration test code across our Dart, Python, and JavaScript WebSocket clients was the same. Maintaining separate test files led to duplicated effort and poor scalability. It was a project architecture challenge: How do we eliminate that 80% duplication while still allowing for the 20% that needs to be different?
   • Solution: Introduced a unified, flexible integration test suite under websocket/test/integration-test, powered by shared helpers and a scalable structure that supports both common and client-specific test logic. I removed duplicate test files and cleanup scripts. Added helper functions to run common tests for shared logic and centralized test setup in a new package.

Check out the implementation in PR #1630.

2. A New Message Validation Library @asyncapi/keeper
   • Problem: Validating message payloads against JSON Schema and AsyncAPI specs is a core need. While some libraries already existed for message validation, they lacked extensive and easy-to-use methods for validating payloads.
   • Solution: I initiated development of @asyncapi/keeper, a reusable message validation library built on @hyperjump/json-schema and @asyncapi/parser for validating payloads against JSON Schema Draft-07 and AsyncAPI specs.

Check out the implementation in PR #1618.

3. Migration of components to @asyncapi/generator-components
   • Problem: The Generator is shifting to a component-based template development with the React Render Engine. In WebSocket templates, we observed recurring patterns where most components performed the same tasks, just implemented differently across languages.
   • Solution: I have migrated several components into the @asyncapi/generator-components package to centralize and standardize template development.

Check out the list of migrated components here.

4. Automating the Review Flow with a PR Checklist Bot
   • Problem: Code reviews can get inconsistent, different reviewers focus on different things, and contributors aren’t always clear on what’s expected. This leads to missed issues, slower approvals, and more back-and-forth.
   • Solution: To streamline reviews, I introduced an automated PR checklist that posts on every pull request, ensuring consistency for maintainers and clarity for contributors.

Check out the implementation in PR #1641.

5. Refactoring Template Configuration Loading
   • Problem: Template configuration loading (loadTemplateConfig and loadDefaultValues) was tightly coupled with generator.js, making the codebase harder to maintain and extend as new config sources (.ageneratorrc) were introduced.
   • Solution: Extracted configuration loading and validation into a new templateConfig module (loader.js and validator.js) for cleaner architecture. This refactor centralized logic, added support for .ageneratorrc (YAML) with fallback to package.json, and improved reliability with comprehensive tests.

Check out the implementation in PR #1655.

Reviewing Pull Requests

Syncing regularly with my mentor has been a game-changer. I take the lead on reviewing PRs initially, and once I feel a PR is ready, my mentor steps in for the final review. This process has helped me learn the nuances of what makes a PR truly great, from clean code to thoughtful commit messages. There’s no official metric to measure growth in PR reviewing, but one cool indicator GitHub provides is the activity graph in your profile.

Overview of my activity in the AsyncAPI organization, highlighting balanced contributions across code reviews, issues, commits, and pull requests.

Improving On-Boarding Documentation

During GSoC, I’ve been focused on improving the Contribution Guide for AsyncAPI Generator, a project that can be overwhelming for newcomers due to its complexity involving APIs, event-driven architecture, AsyncAPI itself and JavaScript coding. I'm continuously updating and adding more points in the Guidelines for new contributors and Tips for effective contributions section in the CONTRIBUTING.md file.

Triaging Issues

One of my key responsibilities has been actively triaging incoming issues and it’s been quite an experience. These experiences reinforced that communication, patience, and process are as critical as code in open source. I’ve shared some of these situations below.

I had to close the PR as the contributor did not make the required changes for a long time after review, blocking other contributions.

I guided a contributor to update a single PR instead of creating multiple PRs and fixed a title casing issue causing CI failure.

I had to close the PR as the contributor opened it without validating the issue.

Learning Outcomes

Through this project, I not only contributed significant improvements to the Generator but also earned recognition as the first Template Champion Maintainer within the repository, with my name added to the CODEOWNERS file. This milestone reflects both technical contributions and the trust I’ve built within the AsyncAPI community.

Technical contributions:

• Advanced expertise in AsyncAPI template development
• Designed and maintained monorepo architectures
• Built modular package designs for scalability
• Implemented integration testing for reliability
• Improved AsyncAPI/JSON Schema validation

Maintainer contributions:

• Triaged issues to keep workflows organized
• Reviewed PRs to maintain quality and consistency
• Enhanced documentation for contributors and users
• Introduced automation to reduce manual effort and streamline processes

This journey took me from contributor to maintainer, giving me the technical depth, community insight, and leadership experience needed to sustain and grow open-source projects.

Acknowledgments

• AsyncAPI Organization: For giving me the opportunity to contribute to an open-source project I’m passionate about, and for providing a supportive community where I could learn, grow, and contribute meaningfully.
• Lukasz Gornicki: My mentor, for guiding me throughout the project, generously sharing his expertise, and inspiring me with his patience, experience, and thoughtful feedback. Our 1:1 meetings gave me so many valuable insights and helped me grow as a maintainer.
• Azeez Elegbede: Our organization admin, for constant support in organizing community bonding events and for keeping the GSoC project on track through regular biweekly sync meetings. Your dedication made the experience smooth and enjoyable.
• Google Summer of Code: For funding the project, giving students like me the opportunity to kickstart our careers, and showing us how exciting, approachable, and rewarding the world of open source can be. I truly wasn’t aware of this before participating.