Automated Schema Generation from Source Code Interfaces
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Creating and publishing schemas for applications with variable interfaces, such as Kafka topics, is a complex and error-prone process, often leading to application downtime due to potential errors in schema definition and format.
Innovation Solution
Automatically generating and publishing schemas directly from source code, which reduces errors and ensures consistency by analyzing the source code to detect and parse interface invocations, determining inputs and outputs, and generating a model that is published to a registry for use by other applications.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If schemas are manually created and published for applications with variable interfaces, then schema definition can be performed, but the process becomes complex and error-prone leading to application downtime
Solution Approach 1:
The system automatically generates schemas by analyzing source code itself, eliminating the need for manual schema creation. The source code serves as both the implementation and the specification, with the system extracting interface definitions and generating appropriate schemas automatically during the build process.
Solution Approach 2:
The patent replaces manual mechanical schema creation with automated computer-based analysis. The system uses source code parsing, interface detection algorithms, and automated schema generation to substitute for manual schema definition processes, reducing human error and complexity.
2Reliability
If manual schema creation is used, then schema definition can be performed, but errors occur leading to application downtime
Solution Approach 1:
The system performs self-service by automatically extracting interface definitions from source code and generating schemas without human intervention. This eliminates manual errors and ensures schema accuracy is tied directly to the actual code implementation.
Solution Approach 2:
The system performs preliminary analysis of the source code during the build process to extract interface definitions before the actual schema is needed. This preliminary extraction ensures schemas are generated accurately from the actual code structure, preventing errors before they occur.
3Productivity
If automated schema generation from source code is implemented, then errors are reduced and efficiency increases, but source code analysis and parsing complexity is introduced
Solution Approach 1:
The build system performs multiple functions: it compiles the source code, analyzes the code structure, extracts interface definitions, and generates schemas all within a single integrated process. This multi-functionality eliminates the need for separate manual schema creation steps while using the existing build infrastructure.
Solution Approach 2:
The system replaces manual schema creation mechanics with automated computer-based source code analysis. By using standard programming languages and data structures to represent interfaces and schemas, the system simplifies the complexity of automated analysis while maintaining high efficiency.
Data Source
AI summary
A system includes a memory and a processor, where the processor is in communication with the memory. The processor is configured to receive a request to build an application, where the application is associated with source code. The source code is analyzed to detect whether a first interface is implemented within the application. The source code is parsed to determine an invocation of the first interface. Inputs and outputs (I/Os) from the first interface are determined based on the invocation of the first interface. A model is generated based on the I/Os associated with the first interface, where the model includes a structure of each of the I/Os. The model is published to a registry.