Dynamic API Call Generation via Graph Schema Traversal
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
As APIs evolve, they often experience code duplication and increased maintenance complexity due to the addition of new functions, leading to inefficiencies in data access and processing.
Innovation Solution
A method is introduced to generate dynamic API calls by traversing a graph representation of the API, decomposing client requests into subqueries based on schema definitions, allowing for customizable interactions without building custom APIs for each function variation, and enabling dynamic extension of APIs by adding new object schemas related to existing nodes.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If new functions are added to extend API functionality, then the API becomes more versatile and adaptable, but code duplication increases and maintenance complexity grows
Solution Approach 1:
The patent implements a universal query processing mechanism that handles multiple API function types (GET, POST, PUT, DELETE) and data operations through a single unified interface. The graph projection system and dynamic query generation enable one core system to serve multiple functionality requirements, eliminating the need for separate code paths for each API extension and thereby reducing maintenance complexity while preserving versatility
Solution Approach 2:
The patent segments the API functionality into discrete, independently definable object schemas that can be composed to create new functions. By breaking down complex API operations into atomic schema components (fields, relationships, operations), the system allows functionality extension through schema composition rather than code duplication, reducing maintenance burden while increasing adaptability
2Adaptability or versatility
If new functions are added to extend API functionality, then the API becomes more versatile, but the amount of code to maintain increases
Solution Approach 1:
The patent uses schema definitions as templates that are dynamically copied and instantiated to generate actual API query code. Instead of manually writing and maintaining separate code for each API function, the system copies schema definitions and automatically generates the corresponding query logic, significantly reducing the volume of maintainable code while enabling unlimited functionality extensions
Solution Approach 2:
The patent performs preliminary action by pre-defining object schemas that encapsulate the structure and behavior of API entities before runtime. These schemas are compiled into a graph projection that prepares the execution plan in advance, eliminating the need to write and maintain ad-hoc query code for each operation, thus reducing code volume while maintaining high adaptability
3Adaptability or versatility
If manual code generation is used for each function variation, then API functionality can be extended, but development time and effort increase significantly
Solution Approach 1:
The patent implements self-service by enabling the API system to automatically generate its own query code from schema definitions without requiring manual programming for each function variation. The dynamic query generation mechanism allows the system to serve its own code generation needs, eliminating repetitive manual development work and significantly reducing development time while maintaining full functionality extension capability
Solution Approach 2:
The patent uses parameter changes by allowing schema definitions to be modified at runtime to reflect new functionality requirements. Instead of manually coding new functions, developers can change schema parameters (fields, relationships, operations) and the system automatically regenerates the corresponding query logic, dramatically reducing development time while enabling continuous functionality extension
Data Source
AI summary
The present disclosure relates to accessing data using dynamically generated application programming interface (API) calls. According to one embodiment, a method generally includes receiving, at a computing system, a data request from a client device. The data request generally identifies a navigable path through a graph projection of the API. The computing system generates an API call to process the data request. To generate the API call for each node in the navigable path, the computing system, identifies a node in the graph projection to access data from and generates a subquery to access data from the node using one or more parameters included in the data request and defined in a schema associated with the node. The computing system executes the one or more subqueries to obtain a result and returns the result of executing the subqueries as a result of the API call.