I'm Thomas Wu, a student from Shanghai, China.

project link: https://github.com/LinkScapeOfficial/API-Doc_Assistant

Project Title: GPT-4 Powered API Documentation Assistant

Project Description:

Developing comprehensive and accurate API documentation is a critical aspect of the API development process. However, it can be time-consuming and error-prone for developers to maintain up-to-date documentation manually. This project aims to create a GPT-4 powered API Documentation Assistant that automates the process of generating and maintaining API documentation by understanding the API code and related information.

The project will involve the following components:

Code Analyzer: A module that can parse and analyze API code (in various programming languages) to extract relevant information, such as endpoints, parameters, request/response structure, and authentication details.

GPT-4 Integration: Integration with the GPT-4 model to generate natural language descriptions, examples, and explanations based on the extracted information from the code analyzer.

OpenAPI and Postman Collection Format Compatibility: Ensure that the generated documentation is compatible with the OpenAPI specification and Postman Collection format, allowing seamless integration with Postman and other API tools.

Documentation Maintenance: Implement a mechanism to monitor changes in the API code and update the generated documentation accordingly, ensuring that it remains accurate and up-to-date.

User Interface: Develop a user-friendly interface that allows developers to interact with the API Documentation Assistant, review and edit the generated documentation, and export it in various formats (e.g., Markdown, HTML, OpenAPI, Postman Collection).

Project Benefits:

Automates the process of generating and maintaining API documentation, reducing the time and effort required by developers.
Improves the quality and accuracy of API documentation by leveraging GPT-4's advanced natural language understanding capabilities.
Enhances developer experience by providing well-structured, comprehensive, and easy-to-understand documentation.
Encourages the adoption of open API specifications, such as OpenAPI and Postman Collection, by making it easier to generate and maintain compatible documentation.
Supports Postman's vision of an API-first world by streamlining the API development process and promoting the use of open source API technologies.

Expected Outcome:

A fully functional GPT-4 powered API Documentation Assistant that can analyze API code, generate and maintain accurate documentation, and seamlessly integrate with existing API tools and specifications.

Summary: Provide a robust solution for following all $ref and assembling as a single document for use at run or build time. Addressing different relative and remote paths, allowing OpenAPI definitions to be managed in an atomic way, but then assembled for use in publishing documentation, generating mock services, testing, and other lifecycle needs.
Supporting narratives:
The Reference Rabbit Hole
JSON Schema bundling finally formalised

Multi-spec considerations:
Relative References in OAS
$ref in JSON Schema
$ref in AsyncAPI

This is an ubiquitous challenge in working with OpenAPI, AsyncAPI, and JSON Schema.

Skills: Need basic understanding of OpenAPI, and JSON Schema.

Mentors: 2-3 mentors will be sourced from our 18+ mentors from across Postman.

Project Size: 175h

Rating: Easy to Medium

Hello,
I’m Prince Rajpoot, 2nd year B-tech student.
I want to contribute to Postman as a part of GSOC 2023.

Postman is a popular tool for API development and testing, and contributing to the project can help you learn more about this area.

I want to suggest an idea:

Data Generator - Random data generator like email, names, zip/postal codes, addresses, mobile number and provide the facility to verify response in random data generator.

What are your views on this? Can I contribute to this idea as a part of GSOC-2023?
I'm really passionate about this project and I believe it has the potential to make a real impact. I would be so grateful for any help you could provide.

-Prince Rajpoot
[email protected]

Brief Description
JSON Schema is designed for validation, but the information in a schema can be used to for a number of other purposes. One of those purposes is data transformation. This project aims to implement some of the transformation uses cases JSON Schema Community has been asking about the last months.

Expected Outcomes

Provide an implementation of the following utilities in any language. They should work with at least the latest version of JSON Schema. Tests should be described in JSON so others who want to write a similar tool in a different language can easily use your tests to ensure compatibility.

• Provide a utility that takes a JSON Schema and a JSON document and adds to the document any values that are missing but have a default specified for that value in the JSON Schema.
• Provide a utility that takes a JSON Schema and a JSON document and removes properties in the JSON document that are not described in the JSON Schema.
• Provide a utility that takes a JSON Schema and a query string from a form post (application/x-www-form-urlencoded) and convert the string to JSON using the JSON Schema to know the types for the values.
  • For example, the string ?foo=1 with schema { "properties": { "foo": { "type": "number" } } } should return { "foo": 1 } rather than { "foo": "1" }.

Skills Required

• A basic understanding of JSON Schema

Mentors
@jdesrosiers

Project Repo: tbd

Expected Difficulty
Easy

Expected Time Commitment
175

Summary: Take any one or more OpenAPI 3.x definitions and loop through and move common objects to be centralized components. In the case of multiple input definitions, the common objects should be extracted to the components section of an external OpenAPI definition. Using the components object to centralize and reuse schemas, parameters, examples, and other elements of an API. Allowing for more efficient and reusable OpenAPI definitions that maximize the components object of the specification.

Skills: Familiarity with the OpenAPI specification.

Mentors: @bavulapati @arvindkalra08 @RaisinTen

Project Repo: https://github.com/postman-open-technologies/openapi-componentizer

Project Size: 175h

Rating: Medium

Suggested by Marc DiPasquale in Slack comment https://asyncapi.slack.com/archives/CQVJXFNQL/p1662141074739369?thread_ts=1661395911.924239&cid=CQVJXFNQL

We should create such an endpoint help/{command} to return instruction of given command to the user. For example help/generate should return available parameters such an available templates etc.

help/{command} is just a suggestion, we can go with other endpoint(s).

Also, what is very important, that endpoint should be done in a similar way as in our main CLI - https://github.com/asyncapi/cli#usage, so main help endpoint should return all available endpoints and particular one like help/generate should return details about given command.

Learn more here asyncapi/server-api#144

Mentors:
@BOLT04

Project Repo:
https://github.com/asyncapi/server-api

Expected Difficulty:
Easy-Medium

Expected Time Commitment:
175 Hour

Our open governance model introduces a TSC that consists of all the CODEOWNERS that want to use their right to have a vote in TSC decisions making process.

We need a bot/github action that will read VOTERS files from all repos, maintain single list, and put it on the website

Description
get a github action that reacts on any push to master and checkes if voters file was edited. Then reads it and add/remove/modify a voter in the list stored on the website
get a github action that on a PR level validates modification in VOTERS file and blocks PR in case VOTERS cannot be added to TSC list as they are affiliated with the company that already reached the limit of representation
decide on structure of VOTERS file
get a mechanism that collects more details about TSC members (social accounts, hire availability, etc)

Learn more here asyncapi/.github#210

Mentors:
@derberg @KhudaDad414

Project Repo:
https://github.com/asyncapi/.github

Expected Difficulty:
Easy-Medium

Expected Time Commitment:
175 Hour

AsyncAPI-Preview + Spectral for VSCode form a perfect combo in terms of UX/DX for asyncapi editing:

with this extension, you can navigate and preview your API definition
while Spectral for VSCode provides inline and listed linting error for common and even custom mistakes
VSCode comes with an API for providing quick/autofixes for linting errors (see https://code.visualstudio.com/docs/editor/refactoring https://code.visualstudio.com/api/references/vscode-api#CodeActionProvider and https://github.com/microsoft/vscode-extension-samples/tree/main/code-actions-sample for an example)

The purpose of this feature is to provide auto-fix refactoring for the most common and standard spectral linting errors for asyncapi:
https://docs.stoplight.io/docs/spectral/1e63ffd0220f3-async-api-rules

Learn more here asyncapi/vs-asyncapi-preview#160

Mentors:
@ivangsa

Project Repo:
https://github.com/asyncapi/vs-asyncapi-preview

Expected Difficulty:
Easy-Medium

Expected Time Commitment:
175 Hour

Summary: Create an open catalog of OpenAPI definitions for each of the Schema.org Types. Providing a robust set of starting OpenAPI templates for teaching or developing new APIs using a design-first approach. Helping save developers work when it comes to starting new APIs, but also help ensure APIs are developed using common standards and are as interoperable as possible.

Skills: Familiarity with the OpenAPI specification, and Schema.org Types.

Expected Outcomes: A public repository of up-to-date OpenAPI 3.1 definitions and validated JSON Schema instances for each of the Schema.org Types. You must share your code used to generate the output definitions, allowing them to be updated as schema.org Types evolve.

Mentors: @MikeRalphson + 1-2 additional mentors to be named.

Project Repo: https://github.com/postman-open-technologies/schema-org-openapi-catalog

Size of Project: 175h or 350h

Rating: Medium skills level

Scope:
No data should be delivered without documentation, which should not only be accessible to users, but also available in machine actionable to enable application driven processing and analysis, APIs, machine learning, or artificial intelligence.

This project aims to explore the integration of metadata standards, such as W3C DCAT (https://www.w3.org/TR/vocab-dcat-2), the Data Documentation Initiative (https://ddialliance.org/), or schema.org (https://schema.org/docs/data-and-datasets.html), with GraphQL APIs to enhance the discoverability, accessibility, and reusability of data. The project will focus on demonstrating how GraphQL schema extensions can be used to inject standard-based metadata into GraphQL-based APIs, thus strengthening the power of the specification and enabling more efficient data processing and analysis through APIs, machine learning, and artificial intelligence. The goal is to align with the FAIR initiative (https://www.go-fair.org/), which promotes data that is Findable, Accessible, Interoperable, and Reusable

Skills: JavaScript, and/or Rust; GraphQL; GraphQL Yoga; JSON/XML; Research Data Management; Metadata standards;

Mentors: Pascal Heus, Doc Jones

Size of Project: 350 hours

Since postman needs to be installed as a separate software many of my friends who were hardcore postman users shifted to thunderclient as it open in vs code. not only my fruiends but many people. so if postman launches their extension it will gain all its lost users bcoz their UI was superb.

I will create a PR to patch the README.

Scope:
This project aims to develop tools for comparing JSON and YAML files to determine if they are the same or closely related. This is in our case particularly important for comparing API definitions that may be published in different formats or change over time across versions. The focus will be on creating algorithms to generate fingerprints and other signatures for these files, which can then be used to compare them for exact or near matches, or to identify differences. The ultimate goal is to create APIs that make these tools available as a service.

Skills: Python, JavaScript, and/or Rust; JSON / YAML; API implementation; Postman;

Mentors: Pascal Heus, ???.

Size of Project: 175 or 350 hours

We need automation tests to run on the PR level which checks the overall build and codebase of the changes made in the PR. It should cover all the aspects of testing the website and the scripts running inside it. The idea of this project is not only to add UI tests, but also to refactor some parts in code to effectively create tests on it.

What are UI tests?
User Interface testing, also known as UI testing or GUI testing, tests the application’s visual elements to validate proper functionality and expected performance. It ensures that UI functions and application components have no defects, such as icons, radio buttons, text boxes, toolbars, color, fonts, checkboxes, windows, and menus. The primary aspects of UI testing are functionality, performance, usability, compliance, and visual design of the software application to make sure the application works successfully and satisfactorily.

Why do we need this?
We do need these tests because of following reasons:

• we have no tests to test the components and the functions inside it.
• more and more scripts are added to the repository
• no tests, means nothing forces us to write clearer and testable small functions.
• soon website maintenance/contribution will become hard as more and more addition of code will make Duplication and inconsistency inside the codebase.

Learn more here asyncapi/website#1090

Mentors:
@akshatnema
@imabp

Project Repo:
https://github.com/asyncapi/website

Expected Difficulty:
Easy-Medium

Expected Time Commitment:
175 Hour

Scope:
No data should be delivered without documentation, which should not only be accessible to users, but also available in machine actionable to enable application driven processing and analysis, APIs, machine learning, or artificial intelligence

This project aims to improve the accessibility and usability of data documentation by developing a GraphQL-based API for the W3C DCAT (https://www.w3.org/TR/vocab-dcat-2) and the Data Documentation Initiative (https://ddialliance.org) metadata standards. These provide a way to describe and organize data, but lack a generic API that enables easy access and integration with other tools. Our initial research (https://medium.com/@plgah/graphql-for-metadata-standards-b6df8fb12f3a) suggests that GraphQL can be used to rapidly create and even auto-generate schemas and APIs for such specifications. We are seeking to further explore this idea which would not only be game changing but lay the ground for a similar approach for other standards.

Skills: GraphQL; GraphQL Yoga; JSON / XML; Postman; Research Data Management; Metadata standards;

Mentors: Pascal Heus, Doc Jones

Size of Project: 175 or 350 hours

Summary:
The world of JSON Schema is immense. JSON Schema tooling exists in countless languages across a variety of uses (data validation of course a noteworthy and prominent one). Implementing the JSON Schema specification(s) in a fully compliant way is not without challenge, meaning as a user of JSON Schema it is important to understand how a particular implementation may deviate such that one can make constructive tooling choices or help implementations improve. Bowtie is a recently created tool to aide in this task, helping to surface the conformance of various JSON Schema tools with the specification by running them against a set of known correct test cases and regularly rendering the results to a web page. But it can do more!

Expected Outcomes:
Enhance (or replace) Bowtie's simplistic current UI so that it most easily answers "what do various implementations say about each test case" -- making it snappier and more featureful
Add support for further JSON Schema implementations by creating Bowtie harnesses in additional languages
Teach Bowtie to compare not only True/False validation results but also the full JSON Schema standardized output formats

Skills Required:
HTML/CSS/Javascript familiarity
Some notion of what JSON Schema is -- or equivalently some experience using a similar data validation tool including writing SQL Schemas for databases
Basic experience with any of a broad set of languages with JSON Schema implementations or curiosity to learn enough about them to write a simple program
Some Python experience a strong plus

Mentors:
@Julian

Project Repo: tbd

Expected Difficulty:
Easy-Medium

Expected Time Commitment:
175 Hour

Small Intro to Glee

Glee is an innovative spec-first framework that empowers developers to build high-performing server-side applications with ease. By allowing users to focus on the business logic of their applications, Glee takes care of the critical aspects of performance, scalability, and resilience, making it an ideal solution for complex production environments. As of now glee supports multiple protocols like websocket, mqtt, kafka and soon HTTP.

Problem Statement

In particular, Glee allows users to create WebSocket servers, which necessitates the implementation of secure and reliable authentication and authorization mechanisms. This ensures that only authorized parties can access and use the WebSocket servers, thereby enhancing the overall security and privacy of the communication channels.

Proposed Solution

By providing users with the tools to develop customized authentication and authorization procedures, Glee would enables them to tailor their servers to their specific needs, ensuring that they meet the highest standards of security and reliability.

We need to support the commonly used methods of authentication that are supported by websocket servers. In general we need to have support for

1. Basic Authentication: This is a simple and widely supported authentication mechanism that uses a username and password to authenticate clients. The client sends the username and password in the HTTP header during the WebSocket handshake, and the server verifies it before establishing the WebSocket connection.
2. Token-Based Authentication: This is a popular authentication mechanism that uses tokens or access keys to authenticate clients. The client sends the token in the HTTP header during the WebSocket handshake, and the server verifies it before establishing the WebSocket connection.
3. OAuth 2.0: This is a widely used authentication and authorization framework that enables clients to obtain access tokens to access protected resources. The client sends the access token in the HTTP header during the WebSocket handshake, and the server verifies it before establishing the WebSocket connection.
4. Mutual TLS Authentication: This is a strong authentication mechanism that uses TLS certificates to authenticate clients. The client sends a client certificate during the WebSocket handshake, and the server verifies it before establishing the WebSocket connection.

Mentors:
@Souvikns @KhudaDad414

Project Repo

https://github.com/asyncapi/glee

Expected Difficulty:
Easy-Medium

Expected Time Commitment:
175 Hour

Technical skills requried

Typescript, nodejs, websocket, EDA basics

In gsoc 2021 me and Jonas Lagoni created the asyncApi simulator which uses the Async Api specification and a related schema defined file to generate aynchronous traffic using asynchronous protocols.

https://github.com/asyncapi/simulator

For gsoc 2023 i aspire to turn the cli application into a full desktop application with multiple features. Along with the creation of the application i will add support for the kafka protocol and create rich documentation for the project.
I will specify further details regarding the desktop application in the following days.

Any thoughts?

Project requirements

• User stories
• Developer stories
• Non functional requirements
• Functional requirements
• Implementation details

Common Vocabulary

Functional requirements

Non-functional requirements

User stories

Developer stories

Implementation details

The collection format is the specification behind Postman collections. It is a portable format that lets you define every aspect of your API requests and workflow in a human and machine-readable way. It has aided most of the widely used features on Postman, which include but are not limited to automated/manual testing, mocking, monitoring and scheduled runs, end-end testing, documentation, etc.

This project will be part of ongoing work to create an increasing amount of learning resources around the format. This project aims at creating an interactive mindmap that is a replica of this one on Whimiscal. The Mind map is intended to get anyone learning about the collection format to do so in an interactive and visual manner. It is meant to help show the different units of a collection, how they are structured together and how each unit can be nested within each other. It is inspired by the OpenAPI mindmap developed by Arnaud Lauret, the API Governance Lead at Postman.

Skills: HTML & CSS, JavaScript, d3 js

Mentors: @Gbahdeyboh, Aanchal Mishra, Yashish Dua

Project Repo: https://github.com/postman-open-technologies/collection-format-mindmap

Size of Project: 175h

Summary: Develop an open-source approach to finding Swagger and OpenAPI definitions on the open web, crawling web pages looking for API definitions, validating them, and them consuming and indexing them as part of an ongoing search. Providing a simple way that developers can find APIs that exist by finding documentation, repositories, and other common aspects of running an API.

Skills: Knowledge of the web, and how to crawl web pages, follow URLs, or utilize an existing solution like Common Crawl.

Expected Outcomes: Provide a simple open-source API that abstracts away the complexity of searching the web for specific terms, helping identify APIs in a sea of web pages. Providing a simple interface that will set in motion an asynchronous searching of the web or corpus of web content looking for APIs. Allowing users to initiate a search, but then return regularly to see the results of the search over time, building up results, but then aggregating them for each pulling via simple API.

Possible mentors: @vinitshahdeo + 1-2 additional mentors

Project Repo: https://github.com/postman-open-technologies/openapi-web-search

Size of Project: 175h

Rating: Medium skills level

Hello Mentors😊! @jansche @ialimustufa

I am a college student pursuing Bachelor in Computer Technology with specialization AIML, I am interested in this project idea.

I have a deep understanding of Python, JavaScript, HTML, CSS, React, REST API and Java. I have been building projects with these technologies.

Next, I will introduce myself by the QAs mentioned in Contribution Guide

Q1) What interests you most about this project ?

I use GitHub and Postman frequetly, and I have known Github API before. I want to be a contributor of Postman Project, I hope I can have some positive impact on the postman project and the entire open source community. And by this project I think I can help a lot of fellow students to search the projects on github.

Q2) As mentors and project coordinators, how can we get the best out of you?

Mentors can give me some directions, and then we can discuss the feasibility together. Then I will continue to develop and improve these suggestions within the specified time, and finally form a good product

Q3) Is there anything that you’ll be studying or working on whilst working alongside us?

I will take this opportunity to learn more about Github API and the art of communication, and enhance my skills in developing a strong project.

Q4) We'd love to hear a bit on your work preferences, e.g. how you keep yourself organized, what tools you use, etc?

Maintaining continuous communication is the most important.
I make sure to communicate regularly with my team members to ensure that there is no deviation in the product route. I'd like to note down my daily tasks on notes to make sure I complete them.

Q5)Once you’ve selected a project from the ideas section, please suggest a weekly schedule with clear milestones and deliverables around it. Alternatively, if you want to propose your own idea then please include outline, goals, and a well-defined weekly schedule with clear milestones and deliverables.

Week 1:

Comprehensively understand the operation mode of GSoC, and deeply study the GitHub API, including some speed restrictions.
Milestone: submit a report of GitHub API and the next specific plan for the mentors' review

Week 2-3:

Develop basic code and conduct preliminary test (such as speed limit display and search function)
Milestone: submit code and test report for mentors' evaluation

Week 4-5:

Modify according to the tutor's suggestion, optimize the search interface, and add more functions (such as search filtering)
Milestone: submit enhanced code and test report for mentors' evaluation.

Week 6-8:

Continue to improve the code and conduct all-round testing. And add some potentially innovative functions.
Milestone: submit final codes and reports for final review and approval.

Summary: Provide a robust yet easy way to search Github for Swagger and OpenAPI definitions. Understanding that there is a lot of noise available, that we only care about OpenAPIs that validate, and that the Github API has rate limits that require you to automate the crawling over time. Providing a robust open-source solution that will crawl public Github repositories for machine-readable API definitions.

Skills: Knowledge of the Github API, and the OpenAPI specification.

Expected Outcomes: An open-source API that allows you to pass in search parameters and then utilize the GitHub API to perform the search, helping simplify the search interface, make rate limits visible as part of the response, and handle conducting a search in an asynchronous way, allowing the user to make a call to initiate, but then separate calls to receive results over time as results come in, helping show outcomes over time.

Mentors: @anshuljain03 + 1-2 additional mentors

Project Repo: https://github.com/postman-open-technologies/openapi-github-search

Size of Project: 175h

Rating: Easy

Strikethrough GSoC contributor application period in Readme File since it is over.

I am claiming it!

Excited to work in this wonderful project .Will be a nice opportunity to work int his and give my contribution in this . I have worked with technologies used and needed for this project .So will be a great learning experience if i get a chance to work on this.

Scope:
No data should be delivered without documentation, which should not only be accessible to users, but also available in machine actionable to enable application driven processing and analysis, APIs, machine learning, or artificial intelligence

This project aims to improve and enhance the open-source Python package Metasheet (https://pypi.org/project/metasheet/), which was developed to facilitate the rapid documentation of datasets using a simple spreadsheet-based template. While this approach is not uncommon, metasheet differentiates itself by being aligned with global standards such as the Data Documentation Initiative (https://ddialliance.org/) and the Generic Statistical Information Model (GSIM), which support the FAIR initiative (https://www.go-fair.org) for making data Findable, Accessible, Interoperable, and Reusable.

The package was initially developed as an internal tool and while functional, it has limited documentation and could benefit from upgrades and enhancements. This project would focus on transforming Metasheet into a robust open-source package, ready for prime time and contribution from other developers, by adding additional functionalities or serializers, improve documentation, and address any underlying code issues.

Skills: Working knowledge of Python; Familiarity with research data management and/or metadata standards and best practices such as FAIR, DDI, GSIM, DCAT is a plus.

Mentors: Pascal Heus (), ???

Size of Project: 175 or 350 hours