Low-code meta-model increment verification method, system, equipment and medium

Abstract

The invention discloses a low-code meta-model increment verification method, system and device and a medium, and belongs to the technical field of low-code application verification. The method comprises the steps that an analysis model constructs a graph structure and an index; generating an incremental to-be-verified sub-graph in response to the change; aggregating equivalent nodes, and generating and multiplexing features by using a graph model; and comparing defect characteristics to output a conclusion and a repair strategy. The system comprises a graph structure construction module, an index construction module, an increment subgraph generation module, a feature reasoning mapping module and a verification analysis module. According to the method, by constructing the physical and virtual semantic fusion graph and extracting the incremental sub-graph, accurate positioning and rapid verification of the change area are achieved, and invalid full-amount calculation is avoided. Meanwhile, by means of structural feature reuse and a task perception attention mechanism of the graph neural network, reasoning overhead is remarkably reduced, deep detection of an interface structure and service logic can be taken into consideration in a self-adaptive mode, and development efficiency and stability of low-code application are greatly improved.

Description

Technical Field

[0001] This invention relates to the field of low-code application verification technology, and specifically to a method, system, device, and medium for incremental verification of low-code meta-models. Background Technology

[0002] With the acceleration of enterprise digital transformation, low-code development platforms, with their visual drag-and-drop interaction and model-driven development philosophy, have become important tools for building enterprise-level applications. In a typical low-code platform architecture, application pages, business logic, and data models are usually abstracted into metadata and stored and run in the form of a large JSON tree structure or abstract syntax tree. To ensure application correctness, the platform usually has a built-in static checker or validation engine that performs real-time validation of user configurations in design mode, such as checking for variable naming conflicts, component property type matching, and reference integrity.

[0003] However, as low-code applications evolve into large-scale core business systems such as ERP and CRM, application complexity is increasing exponentially. Currently, the challenges developers face have shifted from simple syntax correctness to complex logical consistency and architectural compliance. When dealing with deep business logic verification, existing verification techniques based on tree structures and hard-coded rules have revealed some shortcomings: First, the full traversal mechanism has a performance bottleneck in deep dependency analysis. Currently, existing engines use tree traversal algorithms with O(N) complexity, such as the common DFS / BFS traversal algorithms. Although they are adequate for handling single-point syntax checks, they are extremely inefficient when analyzing complex dependency chains across pages and components. In large applications with thousands of components, some minor logical changes may trigger global dependency recalculation, which can easily lead to a surge in invalid calculations, causing operation delays on the browser side and affecting development efficiency.

[0004] Second, the lack of a structured deduplication mechanism leads to a waste of computing power for complex logical reasoning. Low-code applications contain a large number of structurally equivalent components, such as list cells. For simple regular expression validation, repeated calculations are acceptable, but for complex logical reasoning involving context awareness, performing the same computational cost on each repeated instance will result in a huge waste of computing power, failing to take advantage of the optimization space brought by structural redundancy.

[0005] Third, physical isolation creates semantic blind spots across aspects, making it impossible to identify hidden risks. In traditional metadata, UI, data, and logic are physically separated. Existing tools can only verify the existence of syntactic references through ID matching, but cannot understand whether semantic references are reasonable. For example, binding high-density fields to public components, or incorrectly referencing non-batch processing interfaces in loop logic. These operations are syntactically compliant, but traditional tools cannot identify such compliant but erroneous hidden business risks.

[0006] Fourth, hard-coded rules struggle to encompass all non-deterministic architectural flaws. Traditional engines rely on predefined If-Then rules; however, complex logical flaws often exhibit non-deterministic topological characteristics, such as infinite loops caused by specific data flow combinations. Rigid rule engines cannot cover all variations and lack the heuristic reasoning capabilities based on pattern recognition used by senior engineers during code reviews.

[0007] In summary, although existing technologies can effectively solve basic syntax checking, they have significant shortcomings in dealing with deep semantic understanding and identifying defects in complex architectures. There is an urgent need for a new architecture that can have incremental reasoning and semantic awareness capabilities. Summary of the Invention

[0008] In view of the above-mentioned problems, the present invention provides a method, system, device and medium for incremental verification of low-code metamodels.

[0009] Therefore, the technical problem solved by this invention is that existing low-code verification relies heavily on full static scanning, which cannot efficiently cope with frequent application changes and is difficult to capture implicit business logic dependencies between components, resulting in low verification efficiency, high false negative rate, and inability to meet the real-time feedback requirements of agile delivery.

[0010] To address the aforementioned technical problems, this invention provides the following technical solution: a method for incremental verification of a low-code metamodel, comprising parsing a low-code application model, constructing graph structure data to characterize component relationships, the graph structure data including physical connection relationships reflecting the physical hierarchy of components, and virtual semantic connection relationships constructed based on semantic dependencies between components; constructing a metadata dependency index based on the virtual semantic connection relationships; responding to a change operation of at least one component in the low-code application model, obtaining the inverse dependency closure that has a dependency association with the at least one component based on the metadata dependency index, and extracting the neighborhood context in conjunction with the physical connection relationships to generate an incremental subgraph to be verified that limits the verification scope; based on the incremental subgraph to be verified, aggregating structurally equivalent component nodes, selecting representative nodes to input into the graph inference model, generating a high-dimensional feature vector representing business logic, and mapping the high-dimensional feature vector to the structurally equivalent component nodes; calculating the similarity between the high-dimensional feature vector and a preset defect feature vector, outputting a verification conclusion based on the similarity calculation result, and associating a remediation strategy.

[0011] As a preferred embodiment of the low-code metamodel incremental verification method described in this invention, the construction of graph structure data for characterizing component relationships includes: defining the node type range of the graph structure data, the node type range including multi-level metadata entities constituting the low-code application, the multi-level including presentation layer elements and business function elements; extracting the hierarchical nesting structure of the presentation layer elements, directly mapping the hierarchical nesting structure to the physical connection relationship; parsing the configuration attributes of the presentation layer elements, extracting the reference associations pointing to the business function elements in the configuration attributes, ignoring the topological distance in the physical hierarchical structure, and directly establishing a directed connection between the two as the virtual semantic connection relationship.

[0012] As a preferred embodiment of the low-code metamodel incremental verification method of the present invention, the step of generating an incremental subgraph to be verified with a limited verification scope includes: configuring the metadata dependency index as a reverse mapping structure that records reference relationships; based on the reverse mapping structure, retrieving components that have explicit attribute bindings to at least one component and components that have implicit data flow dependencies to form the reverse dependency closure, and defining the components in the reverse dependency closure as core nodes; based on the physical connection relationship, expanding at least one-order physical neighborhood with the core node as the center, and using the components in the physical neighborhood as neighborhood contexts; and extracting a local topology structure composed of the core node, the neighborhood context, and the connection relationship connecting the core node and the neighborhood context as the incremental subgraph to be verified.

[0013] The beneficial effects of this preferred technical solution are as follows: by configuring a reverse mapping structure and a hybrid dependency retrieval mechanism, the complete boundary affected by changes can be accurately located. This solution not only covers explicitly bound directly related components but also delves deeper into related components caused by implicit data flows, effectively avoiding missed detections. Simultaneously, by expanding the physical neighborhood context around the core node, it ensures that although the range of the truncated subgraph is reduced, the local topological environment required for inference is still preserved. This "on-demand truncating" strategy significantly reduces the input size of the graph neural network and greatly improves the response speed of incremental verification while ensuring the integrity of the verification context.

[0014] As a preferred embodiment of the low-code meta-model incremental verification method of the present invention, the aggregated structurally equivalent component nodes include: extracting component attribute features and topological connection features of the constituent nodes contained in the local incremental subgraph model to be verified, and serializing the component attribute features and topological connection features into structural feature fingerprints that uniquely identify the nodes; dividing the constituent nodes based on the structural feature fingerprints to construct at least one topologically equivalent set, and determining the representative node from the topologically equivalent set; after obtaining the high-dimensional feature vector of the representative node through the graph inference model, establishing a feature reuse mapping from the representative node to the remaining nodes in the topologically equivalent set to complete the batch feature update of the topologically equivalent set.

[0015] The beneficial effects of this preferred technical solution are as follows: Addressing the characteristic of low-code applications containing numerous repetitive structural components such as list items and forms, an innovative node aggregation mechanism based on structural fingerprints is introduced. By extracting attributes and topological features, repetitive nodes are categorized, and complex graph reasoning calculations are performed only on representative nodes. Subsequently, batch updates are achieved through feature reuse mapping. This mechanism cleverly utilizes the self-similarity of low-code models, reducing computational complexity from the level of the total number of nodes to the level of pattern categories, significantly reducing memory consumption and inference latency, making millisecond-level real-time verification possible in browsers or resource-constrained environments.

[0016] As a preferred embodiment of the low-code metamodel incremental verification method described in this invention, the generation of high-dimensional feature vectors representing business logic includes: parsing verification task instructions to identify the target dimension emphasized by the current verification task, wherein the target dimension covers the interface structure dimension and the business logic dimension; configuring the weight parameters of the task-aware attention mechanism integrated in the graph reasoning model differently based on the target dimension; increasing the aggregate weight ratio of the physical connection relationship to exceed the virtual semantic connection relationship in response to the target dimension being the interface structure dimension; and increasing the aggregate weight ratio of the virtual semantic connection relationship to exceed the physical connection relationship in response to the target dimension being the business logic dimension.

[0017] The beneficial effects of this preferred technical solution are: it endows the graph reasoning model with adaptive perception capabilities for different verification tasks. The system dynamically adjusts the aggregation weights of physical connections and virtual semantic connections through task dimension analysis. When checking the interface layout, priority is given to physical hierarchical relationships, while when investigating business logic vulnerabilities, emphasis is placed on virtual data flow. This dynamic weighting mechanism solves the problem that a single graph structure cannot simultaneously accommodate multiple heterogeneous verification needs. It eliminates the need to train multiple independent models for different tasks, significantly improving the accuracy of identifying specific defect types and the ability to suppress false alarms while reducing model maintenance costs.

[0018] As a preferred embodiment of the low-code metamodel incremental verification method of the present invention, the step of calculating the similarity between the high-dimensional feature vector and a preset defect feature vector, outputting a verification conclusion based on the similarity calculation result, and associating a repair strategy includes: constructing a defect pattern library, wherein the defect pattern library records the correspondence between the defect feature vector and the defect type identifier and repair suggestions; calculating the similarity value between the high-dimensional feature vector and each defect feature vector in the defect pattern library; filtering target defect feature vectors whose similarity value exceeds a preset judgment threshold, and determining the defect type identifier that has a correspondence with the target defect feature vector as the verification conclusion; extracting the repair suggestions based on the correspondence, and outputting a repair strategy.

[0019] As a preferred embodiment of the method for incremental verification of a low-code meta-model according to the present invention, the method further includes a training step for constructing the graph inference model: collecting historical low-code application models to construct a sample graph dataset; performing random graph data augmentation transformation on the sample graphs in the sample graph dataset to generate semantically consistent augmented views, and forming positive sample pairs with the sample graphs; randomly sampling heterogeneous nodes without topological association from the sample graph dataset to form negative sample pairs; optimizing the parameters of the graph inference model based on a contrastive learning objective function, driving the graph inference model to map the feature vectors of the positive sample pairs to the neighborhood space, and mapping the feature vectors of the negative sample pairs to the estrangement space.

[0020] To address the aforementioned technical problems, the present invention also provides the following technical solution: a system for incremental verification of a low-code metamodel, comprising: a graph structure construction module, used to parse a low-code application model and construct graph structure data for characterizing component relationships, wherein the graph structure data includes physical connection relationships reflecting the physical hierarchy of components, and virtual semantic connection relationships constructed based on semantic dependencies between components; an index construction module, used to construct a metadata dependency index based on the virtual semantic connection relationships; and an incremental subgraph generation module, used to respond to a change operation of at least one component in the low-code application model and, based on the metadata dependency index, obtain dependencies that exist with the at least one component. The system employs a multi-module approach: first, it identifies the associated reverse dependency closures and extracts neighborhood context based on the physical connections to generate an incremental subgraph to be verified, limiting the verification scope. A feature reasoning and mapping module aggregates structurally equivalent component nodes from the incremental subgraph, selects representative nodes to input into the graph reasoning model, generates high-dimensional feature vectors representing business logic, and maps these high-dimensional feature vectors to the structurally equivalent component nodes. A verification analysis module calculates the similarity between the high-dimensional feature vectors and pre-set defect feature vectors, outputs verification conclusions based on the similarity calculation results, and associates them with remediation strategies. A model training module collects historical low-code application models to construct a sample graph dataset.

[0021] The present invention provides a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps of the method for incremental verification of a low-code meta-model.

[0022] The present invention provides a computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the steps of the method for incremental verification of a low-code meta-model.

[0023] The beneficial effects of this invention are as follows: By constructing a physical and virtual semantic fusion graph and extracting incremental subgraphs, this invention achieves accurate localization and rapid verification of changed regions, avoiding invalid full-scale computation. Simultaneously, by utilizing the structural feature reuse of graph neural networks and the task-aware attention mechanism, it significantly reduces inference overhead and can adaptively balance deep detection of interface structure and business logic, greatly improving the development efficiency and stability of low-code applications. Attached Figure Description

[0024] To more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0025] Figure 1 This is a flowchart of a method for incremental verification of a low-code metamodel, provided as an embodiment of the present invention.

[0026] Figure 2 This is a schematic diagram illustrating the mapping relationship between application models and heterogeneous graphs in a low-code platform.

[0027] Figure 3 This is a schematic diagram of the construction of the incremental subgraph to be verified.

[0028] Figure 4 This is a schematic diagram of the process of structural fingerprint extraction, clustering, and graph embedding vector generation. Figure 5 This is a schematic diagram of the training process based on the triplet loss function. Detailed Implementation

[0029] To make the present invention more apparent and understandable, specific embodiments of the present invention are described in detail below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of the present invention, not all of them. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the protection scope of the present invention.

[0030] Example 1, referring to Figure 1 As one embodiment of the present invention, a method for incremental verification of a low-code metamodel is provided, comprising: S1: Parse the low-code application model and construct graph structure data to represent component relationships. The graph structure data includes physical connection relationships that reflect the physical hierarchy of components, and virtual semantic connection relationships constructed based on semantic dependencies between components. S2: Construct a metadata dependency index based on the virtual semantic connection relationship; S3: In response to a change operation of at least one component in the low-code application model, obtain the reverse dependency closure that has a dependency relationship with the at least one component based on the metadata dependency index, and extract the neighborhood context in combination with the physical connection relationship to generate an incremental subgraph to be verified with a limited verification scope. S4: Based on the incremental subgraph to be verified, aggregate structurally equivalent component nodes, select representative nodes to input the graph inference model, generate high-dimensional feature vectors representing business logic, and map the high-dimensional feature vectors to the structurally equivalent component nodes; S5: Calculate the similarity between the high-dimensional feature vector and the preset defect feature vector, output the verification conclusion based on the similarity calculation result, and associate it with the repair strategy.

[0031] It should be noted that existing low-code platform verification mechanisms typically employ a full static scan approach. This means that even minor changes to the application model require the system to re-parse the entire application tree, resulting in significant waste of computing resources and delayed verification responses. Furthermore, traditional methods are often limited to checking parent-child relationships based on the physical DOM structure, making it difficult to detect implicit data flow dependencies across levels, easily leading to missed detections of deep business logic defects. For complex applications containing numerous list items or repetitive forms and other structurally similar components, performing repetitive reasoning node by node also significantly slows down overall verification efficiency.

[0032] Therefore, to address the aforementioned problems, this invention achieves efficient incremental verification through a series of steps. First, it parses the low-code application model, constructs a graph structure data that integrates physical hierarchical relationships and virtual semantic connections, and establishes a metadata dependency index based on this. Then, in response to component change operations, it quickly locates the reverse dependency closure using the index and generates an incremental subgraph to be verified by combining it with the physical context. Next, based on the subgraph, it aggregates structurally equivalent component nodes, selects representative nodes to input into the graph inference model to generate high-dimensional feature vectors, and reuses the calculation results to map to similar nodes. Finally, it calculates the similarity between the high-dimensional feature vector and the pre-set defect feature vector, outputs the verification conclusion, and associates it with a remediation strategy.

[0033] This invention, by constructing a graph structure with dual connections, can accurately capture complex business logic dependencies. Utilizing incremental subgraph generation technology, verification is performed only on the localized areas affected by changes, completely avoiding unnecessary full-scale computations. Combined with an aggregation reasoning mechanism based on structurally equivalent nodes, the computational overhead caused by duplicate components is significantly reduced. This enables low-code platforms to achieve millisecond-level real-time incremental verification while maintaining high coverage, significantly improving application development efficiency and delivery quality.

[0034] Example 2, refer to Figures 2 to 4 This is one embodiment of the present invention. Based on the previous embodiment, a method for incremental verification of low-code meta-models is provided.

[0035] S1: Parse the low-code application model and construct graph structure data to represent component relationships. The graph structure data includes physical connection relationships that reflect the physical hierarchy of components, as well as virtual semantic connection relationships constructed based on semantic dependencies between components.

[0036] Specifically, in step S1, a heterogeneous graph structure is constructed. This includes the following steps A1-A3: A1: Define the range of node types for graph structure data. The multi-level metadata entities that make up a low-code application are divided into presentation layer elements. and business function elements The presentation layer elements encompass page containers, layout components, and basic user interface controls, specifically including input boxes, dropdown selectors, container panels, and operation buttons. The business function elements encompass data model fields, application interface definitions, and workflow nodes, specifically including database tables, view fields, server-side interfaces, front-end interactive scripts, scheduled tasks, and role definitions and row-level data permission rules. Preferably, a unique type encoding identifier is assigned to each type of node so that the subsequent heterogeneous graph neural network model can learn the specific embedding representations of different types of nodes.

[0037] A2: Extract the hierarchical nesting structure of presentation layer elements and directly map the parent-child containment relationships in the Document Object Model tree to physical connection relationships. .like Figure 2 As shown, for any two presentation layer nodes ,like for If the direct parent container is the edge, then the edge is established. .

[0038] For example, in a specific page, there is a layout container, and a button component is placed inside the layout container. Then, in the heterogeneous graph, directed physical edges are created from the page node to the layout container node, and from the layout container node to the button node, so as to completely replicate the physical layout structure of the interface.

[0039] A3: Parse the configuration attributes of the presentation layer elements and extract the references pointing to business function elements from the configuration attributes. Ignore the topological distance in the physical hierarchy and directly establish directed connections between the presentation layer elements and business function elements as virtual semantic connections. For presentation layer nodes With business function nodes ,like The property expression explicitly calls If the identifier is specified, then an edge is established. .

[0040] In practice, a static taint analysis technique based on abstract syntax trees is employed. This technique traverses all attribute values ​​of user interface component nodes. If an attribute value contains an expression with a specific pattern, the parser extracts the root node and specific fields of the referenced data object and searches for the corresponding unique identifier of the backend entity in the global symbol table. At this point, the system skips intermediate layers such as pages, layouts, forms, and contexts, directly generating a virtual semantic edge between the user interface component node and the data entity node. This approach shortens logical nodes that previously required multiple hops to connect to direct neighbors, enabling heterogeneous graph neural networks to directly capture cross-layer business dependencies and effectively solve the information dilution and oversmoothing problems that occur in traditional graph neural networks during long-distance message transmission.

[0041] In this embodiment of the application, the metadata dependency index built based on the virtual semantic connection relationship in step S2 is configured with an inverted index structure and a hash mapping table to achieve fast key-value pair lookup of the reference relationship.

[0042] Specifically, configuring the inverted index structure in step S2 includes the following steps B1-B2: B1: Traverse all virtual semantic connections Extract the target node of each edge as the index key and the source node as the index value.

[0043] Specifically, the system scans the set of virtual semantic connections constructed in step S1. For each directed edge from the source node to the target node, it identifies the target node as the referenced object, such as an application interface definition or a data model field; and identifies the source node as the initiator of the reference, such as a button component that triggers the call or a text box component that displays data. The unique identifier of the target node is extracted as the key, and the unique identifier of the source node is extracted as the value, forming a basic key-value pair data stream.

[0044] B2: Construct a hash table This is a reverse mapping structure used to record reference relationships. For any business function element... Its value in the mapping table is the set of all presentation layer elements that depend on that element. Thus supporting Reverse lookup with time complexity.

[0045] Specifically, an efficient hash table is maintained in memory to aggregate the key-value pairs extracted in step B1. For the same target node, all its corresponding source node identifiers are aggregated into a list or set and stored in the target node's hash bucket. For example, when the target node is a specific application interface, its value in the hash map table contains a list of identifiers for all front-end pages, logic flows, and report data sources that have called that interface. Through this inverted index structure, when a change to that application interface is subsequently detected, the system can retrieve the relevant information in a single hash lookup operation without traversing the entire graph. The time complexity is directly applied to all affected upper-level components, making this mechanism particularly suitable for handling complex low-code applications containing tens of thousands of nodes.

[0046] In an alternative implementation, the metadata dependency index built in step S2 can also store connection relationships through a graph database engine, mapping component nodes and dependency edges to points and edge entities in the graph database, and directly retrieving multi-hop dependency paths using a graph query language.

[0047] Specifically, the heterogeneous graph data constructed in step S1 is persistently stored in a graph database, such as Neo4j or NebulaGraph. Presentation layer elements and business function elements are mapped to vertices in the graph database, and physical connections and virtual semantic connections are mapped to edges with specific labels. When dependencies need to be retrieved, query statements are written using graph query languages ​​such as Cypher or Gremlin. This not only retrieves direct references but also, by setting path depth parameters, directly retrieves indirect dependency paths with multi-hop depths, such as finding "component A depends on component B, which in turn depends on component C," thereby achieving precise tracking of deep-level cascading effects.

[0048] In another alternative implementation, the metadata dependency index in step S2 can also be constructed by constructing a sparse adjacency matrix to represent the dependency relationship, mapping the components to matrix row and column indices, and using matrix multiplication operations to quickly calculate and identify the propagation path of indirect dependencies.

[0049] Specifically, construct a dimension as A sparse adjacency matrix, where This represents the total number of components in the application. If the components... Depends on components Then the first element in the matrix will be... Line 1 Column elements are set to 1 otherwise and 0 otherwise. To identify indirect dependencies, exponentiation or Boolean matrix multiplication is performed on the sparse adjacency matrix. For example, the positions of non-zero elements in the result of matrix squaring indicate the existence of second-order dependencies. Utilizing the compressed storage format and parallel computing capabilities of sparse matrices, all potential transitive dependencies can be quickly derived through algebraic operations without explicitly traversing the graph structure, making it particularly suitable for large-scale batch verification scenarios.

[0050] S3: In response to a change operation of at least one component in the low-code application model, obtain the reverse dependency closure that has a dependency relationship with the at least one component based on the metadata dependency index, and extract the neighborhood context in combination with the physical connection relationship to generate an incremental subgraph to be verified with a limited verification scope.

[0051] In this embodiment of the application, the incremental subgraph to be verified with a limited verification scope generated in step S3 is obtained by acquiring the reverse dependency closure and combining it with the physical neighborhood context of a fixed depth to extract the local topology.

[0052] like Figure 3 As shown, a subgraph is generated in step S3. This includes the following steps C1-C3: C1: Define the set of change components Based on the reverse mapping structure Retrieve all components that have explicit property bindings and implicit data flow dependencies on the changed component, forming a reverse dependency closure. This set of closures contains all potential risk points that may be affected by the changes.

[0053] Specifically, the system listens to the operation event stream of the low-code designer to identify the target nodes modified by the user. It then uses the hash map table built in step S2 for fast lookup. First, it searches for explicit dependencies; for example, when a user modifies the return parameter structure of an application interface, it quickly finds all front-end pages and logic flow nodes that call that interface through the index. Second, it searches for implicit data flow dependencies; for example, if the target node is a numeric input box, and its value, although not directly referenced and displayed, is passed as a parameter to a back-end calculation formula, then that calculation formula node is also identified as having a dependency relationship. All the nodes directly or indirectly affected form a set of reverse dependency closures.

[0054] C2: Define the components in the reverse dependency closure as core nodes. Based on physical connection relationships Expanding from the core node The physical neighborhood is defined as the physical neighborhood context, where components within the physical neighborhood are used as the neighborhood context. Here This is a preset context depth hyperparameter.

[0055] Specifically, simply extracting the affected core nodes is insufficient to support inference in graph neural networks, because the feature aggregation operation of graph neural networks is highly dependent on the feature information of neighboring nodes. Therefore, this step is performed... The order extension operation, preferably, is to Set to 1. For each core node in the set of reverse dependency closures, retrieve all its directly connected physical neighbors in the heterogeneous graph, including parent container components and sibling components. Although these components in the involved physical neighborhood are not modified by the user and are not affected themselves, they provide the layout structure features and environmental context features necessary for the core node to function properly.

[0056] C3: Extract the local topology consisting of the core node, its neighborhood context, and the edges connecting them, as an incremental subgraph to be verified. ,in .

[0057] Specifically, using subgraph sampling techniques, the core nodes and their context neighbors are extracted from the full application graph to form an independent connected subgraph that retains the original node features and edge attributes. This incremental subgraph to be verified is input into the subsequent model as an independent computational unit or batch, thereby reducing the computational load from the full graph level to the local subgraph level and achieving millisecond-level real-time verification response.

[0058] In an optional implementation, the incremental subgraph to be verified in step S3, which limits the scope of verification, can also be generated by a random walk-based sampling strategy. Starting from the changed component, the graph structure is randomly hopped, the node access frequency is counted, and nodes with access frequencies higher than a preset value are included in the subgraph to be verified.

[0059] Specifically, starting from the changed component node, multiple random walk paths are simulated. At each step, the next neighbor node is selected based on the edge weight probability. After multiple iterations, the number of times each node is visited in the entire graph is counted. The higher the visit frequency, the stronger the structural correlation between the node and the changed component. The system sets a frequency threshold and only retains nodes whose visit frequency exceeds the threshold to form a subgraph to be verified, thereby dynamically capturing the diffusion range of the change's impact.

[0060] In another optional implementation, the incremental subgraph to be verified in step S3, which limits the scope of verification, can also extend the context by semantic rules based on meta-paths, predefine specific semantic path patterns such as event triggering-action execution-data update, and extract only the nodes on the path that conforms to the pattern to form the subgraph.

[0061] Specifically, a set of meta-path patterns that can represent specific business logic are predefined, such as "a button click event triggers a logic flow, which in turn updates the data entity." When generating the subgraph, starting from the changed node, the search and expansion are strictly performed along the edges that conform to the definition of the meta-path, extracting only nodes on that specific semantic chain. This approach can effectively filter out background noise nodes that are irrelevant to the current business logic, resulting in a more concise and semantically focused subgraph.

[0062] It should be noted that the incremental verification strategy used in this embodiment has a significant advantage in computational efficiency. Traditional static code analysis typically requires traversing the entire abstract syntax tree, and its time complexity is proportional to the total number of application nodes. They exhibit a linear correlation. However, this embodiment constructs an incremental subgraph using inverse dependency closures, strictly limiting the verification scope to the affected local region, thus reducing the inference time complexity to a value proportional to the size of the closure set. Related. In real-world large-scale enterprise application scenarios, the size of the closure collection... Typically much smaller than the total number of application nodes. For example, the total number of application nodes. The number could reach tens of thousands, and the size of the set of closures affected by the change... Typically, there are only a few dozen nodes. This difference in scale ensures that verification time does not increase linearly with the growth of the application, thus enabling millisecond-level real-time responses that are imperceptible to the user.

[0063] S4: Based on the incremental subgraph to be verified, aggregate structurally equivalent component nodes, select representative nodes to input the graph inference model, generate high-dimensional feature vectors representing business logic, and map the high-dimensional feature vectors to the structurally equivalent component nodes.

[0064] Specifically, feature calculation and reuse are performed in step S4, such as... Figure 4 As shown, it includes the following steps D1-D3: D1: Extract component attribute features of each node in the local incremental subgraph model to be verified. And topological connectivity features, these two types of features are serialized into structural feature fingerprints that uniquely identify nodes using a hash algorithm. .

[0065] Specifically, a feature serialization function is defined to traverse the nodes in the subgraph and extract their component type codes, key configuration attributes, and type signatures of adjacent edges. To ensure the structural fingerprint is visually independent, a whitelist mechanism or information entropy filtering strategy is used to retain only the set of attributes that have a substantial impact on business logic, such as data binding paths, interaction event scripts, and validation rules, while automatically removing purely visual attributes such as background color, font size, and margins. The filtered features are concatenated into a string sequence and subjected to MD5 or SHA-256 hash operations; the generated hash value is the structural feature fingerprint of that node.

[0066] D2: Partition nodes based on structural feature fingerprints and construct topologically equivalent sets. such that the same set All nodes within the set have the same fingerprint. A node is randomly selected from each set as the representative node. .

[0067] Specifically, an inverted index structure based on a hash table is maintained in memory. The incremental subgraph to be verified, determined in step S3, is traversed. For each node, its structural feature fingerprint is calculated as the key, and the node identifier is appended to the corresponding hash bucket value list. For example, if there is a list component containing one hundred rows of data in the designer, although these one hundred row components have different unique identifiers, their component types, configuration attributes, and connection relationships are completely identical. Therefore, they will generate the same hash value and be grouped into the same hash bucket.

[0068] Next, we iterate through each non-empty bucket in the hash table-based inverted index structure, selecting by default the identifier of the first node in the list of that bucket as the representative node of the equivalence group of that structure, denoted as . The system then marks all other nodes in the bucket as subordinate nodes. To support subsequent bidirectional operations, the system establishes two key mapping tables: one is a forward compression table, which records the mapping relationship between the structure hash value and the unique identifier of the representative node, ensuring that the system can quickly locate the corresponding computing agent through fingerprints; the other is a reverse broadcast table, which records the index relationship between the unique identifier of the representative node and the set of all original node identifiers in the equivalence group of the structure, that is, maintaining the corresponding association between each representative node and the complete list of the group, including itself and all subordinate nodes.

[0069] When preparing input data for heterogeneous graph neural networks, instead of loading the full graph data, only the data from the graph itself is loaded. A computational graph is constructed using representative nodes. Specifically, for each representative node, in the incremental subgraph to be verified, its first-order physical neighborhood and virtual semantic neighborhood are indexed based on the adjacency matrix, and the corresponding neighbor node feature vectors and edge feature vectors are extracted. The local subgraph features representing each node are concatenated into a compact feature tensor, the dimension of which is the original total number of nodes. corresponding Compressed to represent the number of nodes corresponding ,in This is a feature dimension. This step fully leverages the high repetition rate of components in low-code platforms. In complex forms or long lists, the actual number of unique component patterns $M$ may only be single digits, while the number of instances... It can reach hundreds.

[0070] Subsequently, the compressed tensor is fed into a graphics processing unit (GPU) or AI acceleration unit to perform matrix operations. The complexity of standard graph convolution operations is linear or superlinear with the number of nodes. If clustering is not performed, the entire tensor needs to be processed. Each node performs high-dimensional matrix multiplication; however, in this embodiment, the heterogeneous graph neural network model only performs high-dimensional matrix multiplication on each node. Each representative node performs inference. Because... This significantly reduces memory usage and the number of floating-point operations, making real-time inference possible in front-end browser environments or resource-constrained edge servers.

[0071] D3: Parse the verification task instructions to identify the target dimension of the current verification task. The weight parameters of the task-aware attention mechanism integrated into the target dimension-differentiated configuration graph reasoning model are determined. When referring to the interface structure dimension, configure the aggregation weight of physical connection relationships. The aggregate weight of virtual semantic connection relationship is greater than ;when When referring to the business logic dimension, configuration . will represent the node Input the configured graph inference model to generate high-dimensional feature vectors. And establish a feature reuse mapping, and Assigning to a collection The remaining nodes complete the batch feature update.

[0072] Specifically, upon receiving verification commands from the system, the system identifies whether the current task focuses on the interface structure dimension or the business logic dimension. When the focus is on the interface structure dimension, the aggregate weight of configuring physical connections is greater than the aggregate weight of configuring virtual semantic connections; when the focus is on the business logic dimension, the aggregate weight of configuring virtual semantic connections takes precedence.

[0073] Preferably, this weight configuration is achieved by adding a learnable mask matrix or bias term controlled by the task type before the Softmax normalization function of the graph attention layer. For example, for a business logic detection task, a mask bias of negative infinity is applied to the attention score of the physical edge, thereby suppressing the weight of the physical edge in terms of probability distribution.

[0074] The representative node is input into the configured graph inference model to generate a high-dimensional feature vector. A feature reuse mapping is established, and using memory address references or index alignment, the high-dimensional feature vector calculated by the representative node is directly assigned to the remaining subordinate nodes in the topological equivalence set. It completes batch feature updates in a time complexity of [time complexity].

[0075] In this embodiment of the application, step D3, which involves aggregating neighborhood information using a graph reasoning model, employs a weighted aggregation method using a graph attention network (GAT) architecture, including the following steps D311-D313: D311: For each connection in the incremental subgraph to be verified, calculate the attention coefficient between the source node and the target node. This coefficient represents the importance of the neighboring node to the central node.

[0076] Specifically, a shared linear transformation matrix is ​​used to map node features to a high-dimensional space, and the transformed features of the source and target nodes are concatenated. The concatenated vector is then input into a single-layer feedforward neural network to calculate the original attention score.

[0077] D312: Attention coefficients are processed using the LeakyReLU activation function and Softmax normalization operation, transforming them into normalized weights in the form of a probability distribution to distinguish the different contributions of physical connections and virtual semantic connections.

[0078] Specifically, the task-aware weighting strategy determined in step D3 is introduced, and different types of edges are multiplied by corresponding adjustment coefficients in the Softmax operation, so that the model can dynamically focus on physical or semantic neighbors according to the context of the current validation task.

[0079] D313: Based on normalized weights, the feature vectors of all first-order neighbor nodes are weighted and summed, and the output of the multi-head attention mechanism is fused to generate new node features that integrate structural and semantic information.

[0080] Specifically, a multi-head attention mechanism is used to compute multiple independent attention distributions in parallel, and the output features of each head are concatenated or averaged to capture the rich semantic information of nodes in different representation subspaces. Finally, the updated node embedding vector is output through a nonlinear activation function.

[0081] In an alternative implementation, for aggregating neighborhood information using a graph reasoning model, the aggregation method can also be to perform spectral domain aggregation using a graph convolutional network (GCN) architecture, including the following steps D321-D323: D321: Construct the adjacency matrix and degree matrix of the incremental subgraph to be verified, and calculate the normalized form of the Laplacian matrix to capture the global topological structure of the graph.

[0082] Specifically, a weighted adjacency matrix is ​​constructed based on task weights. And calculate its corresponding normalized Laplace operator: in It is a degree matrix.

[0083] D322: Performs graph convolution operation, multiplying the normalized Laplacian matrix with the node feature matrix and the learnable weight matrix to achieve smooth diffusion of features across the topological structure.

[0084] Specifically, through matrix multiplication: The information aggregation of all nodes is completed at once, and the properties of spectral graph theory are used to enable features to propagate synchronously in the physical and semantic channels.

[0085] D323: Introduces nonlinear transformation through ReLU activation layers, superimposes multiple layers of graph convolution operations to expand the receptive field, aggregates feature information from higher-order neighborhoods, and finally outputs the spectral domain feature representation of the nodes.

[0086] In another alternative implementation, for aggregating neighborhood information using a graph reasoning model, the aggregation method can also be inductive aggregation using the GraphSAGE architecture, including the following steps D331-D333: D331: Centered on the representative node, it performs fixed-length random sampling in the physical and semantic neighborhoods to obtain a fixed number of neighbor node samples in order to handle the computational overhead of large-scale graph data.

[0087] Specifically, the sampling depth and the number of samples per layer are set. For example, the first layer samples 10 neighbors and the second layer samples 5 neighbors, thereby limiting the size of the computation graph to a fixed range and avoiding memory explosion caused by super nodes.

[0088] D332: Using a mean aggregator or an LSTM aggregator, the features of the sampled neighbor nodes are aggregated to generate a neighborhood feature vector.

[0089] Specifically, for each node, the feature vectors of all its sampled neighbors are averaged element-wise or input into a long short-term memory network to extract the statistical features of the neighborhood.

[0090] D333: The current feature representing the node itself is concatenated with the generated neighborhood feature vector, and the dimension is transformed through a fully connected layer to update the feature representation of the node.

[0091] S5: Calculate the similarity between the high-dimensional feature vector and the preset defect feature vector, output the verification conclusion based on the similarity calculation result, and associate it with the repair strategy.

[0092] Specifically, vector matching is performed in step S5, including the following steps E1-E2: E1: Construct a defect pattern library, which records pre-defined defect feature vectors. The correspondence between defect type identifiers and repair suggestions. Calculate the high-dimensional feature vectors of representative nodes. Cosine similarity with each defect feature vector in the library.

[0093] Specifically, the system pre-loads a defect pattern library generated based on contrastive learning, which contains standard feature vectors for various known logical vulnerabilities. This is applied to the representative node feature vector output in the current step S4. Iterate through each defect feature vector in the pattern library. The cosine similarity between the two can be calculated using the following formula. : E2: The similarity value exceeds the preset threshold. The target defect feature vector is used to identify the defect type that corresponds to the target vector as the verification conclusion, and repair suggestions are extracted based on the correspondence as the repair strategy output.

[0094] In this embodiment of the application, step E2 involves calculating similarity using a vector space metric algorithm. The calculation method is to use a cosine similarity algorithm to measure directional consistency, including the following steps E211-E213: E211: Calculate the L2 norm of the high-dimensional feature vector and the defect feature vector respectively, that is, the magnitude of the vector, to eliminate the influence of the absolute value of the vector.

[0095] E212: Calculate the dot product of the high-dimensional feature vector and the defect feature vector, and obtain the projection overlap of the two vectors in the feature space by accumulating the product of the components of each dimension.

[0096] E213: Divide the dot product result by the product of the magnitudes of the two vectors to obtain a cosine value ranging from negative one to positive one. The closer the value is to positive one, the more similar the business logic features and defect patterns are in the semantic direction.

[0097] In an alternative implementation, for calculating similarity using a vector space metric algorithm, the calculation method can also be to use an Euclidean distance algorithm to measure the absolute spatial distance, including the following steps E221-E223: E221: Calculate the numerical difference between the high-dimensional feature vector and the defect feature vector in each feature dimension to obtain the difference vector.

[0098] E222: Squaring each component of the difference vector and summing them gives the squared distance between the two vectors in the feature space.

[0099] E223: The square root of the squared distance is used to obtain the Euclidean distance, and the distance value is inverted or normalized by its reciprocal. The smaller the distance, the higher the similarity value.

[0100] In another alternative implementation, for calculating similarity using a vector space metric algorithm, the calculation method can also be an interactive metric using a bilinear neural tensor network, including the following steps E231-E233: E231: Construct a scoring network with a bilinear tensor layer that introduces a learnable correlation matrix to capture the complex nonlinear interaction between two vector features.

[0101] E232: Input high-dimensional feature vectors and defect feature vectors into the scoring network, and mine second-order cross information between feature dimensions through tensor product operation, rather than just comparing corresponding dimensions.

[0102] E233: The scalar output of the network is mapped to a probability value between zero and one by using the Sigmoid activation function. This probability value directly represents the confidence that the high-dimensional feature vector belongs to a specific defect type.

[0103] Furthermore, in step E2, regarding the preset judgment threshold, this embodiment preferably adopts a dynamic adaptive threshold mechanism based on statistical distribution, rather than a fixed constant.

[0104] Specifically, the system maintains a sliding window to record the most recent... The similarity distance distribution of subnormal design nodes is calculated in real time, and its mean is also calculated. and standard deviation The judgment threshold is dynamically set to... This kind of based The dynamic mechanism of the rule can automatically adapt to the drift of the model output distribution under different business scenarios, thereby significantly reducing the false alarm rate while ensuring a high detection rate.

[0105] Furthermore, in step E2, the extracted repair suggestions are output as a repair strategy, specifically including strategy mappings for the following typical defect types: The first type is circular dependency defects. When it is detected that two or more logical flow nodes form a closed loop call, which leads to the risk of stack overflow, the extracted remediation strategy is to automatically insert a circuit breaker logical node in the call chain or modify the synchronous call attribute to an asynchronous message queue call.

[0106] The second category is the N+1 query performance defect. When it is detected that a single data query interface is directly bound in the loop list component, the extracted repair strategy is to suggest replacing the single query interface with a batch aggregation query interface and setting the front-end cache property of the data source to the enabled state.

[0107] The third category is the vulnerability of sensitive data being exposed beyond authorization. When it is detected that a data field marked as confidential is bound to a public user interface component without access control, the extracted remediation strategy is to suggest adding a de-identified display attribute to the component or automatically generating an authentication container to wrap the component.

[0108] Furthermore, this embodiment also provides a flexible deployment architecture that adapts to different application scales, balancing verification accuracy, response speed, and system resource constraints. Specifically, the system adaptively selects one of the following two deployment modes based on the order of magnitude of the low-code application's component size: Mode 1: Browser-based full inference mode for lightweight applications. When the number of application components is detected to be below a preset threshold, such as less than 1,000 components, a pure front-end deployment solution is adopted. A lightweight graph neural network model compressed using knowledge distillation technology is loaded onto the browser, with the model size preferably controlled between 5 and 10 megabytes. Using the ONNXRuntimeWeb's WebAssembly backend or the TensorFlow.js framework, full-link inference computation combining incremental subgraph sampling and structural fingerprint clustering techniques is directly executed on the user's local device. This mode does not require network data backhaul and can achieve zero-latency offline verification.

[0109] Mode 2: Cloud-edge collaborative hybrid deployment mode for large-scale applications. When the number of application components exceeds a preset threshold, for example, more than one thousand components, a layered computing architecture is adopted. Less computationally expensive preprocessing steps, including structural fingerprint extraction, metadata dependency index construction, and reverse dependency closure retrieval, are performed on the browser side. Computationally intensive deep inference steps are offloaded to the server or edge computing nodes. These deep inference steps encompass multi-layer convolutional operations of heterogeneous graph neural networks, attention weight calculation, and vector similarity retrieval for a large-scale defect database. The browser submits compressed subgraph features via an asynchronous application programming interface (API) and receives verification results from the server. Furthermore, the verification results are persistently cached in browser-local storage media such as IndexedDB to accelerate subsequent repeated queries with the same structure.

[0110] Preferably, to address the issue of user interface lag caused by complex verification logic occupying the main thread, this embodiment employs a multi-threaded parallel computing architecture based on WebWorker. Specifically, the index construction in step S2, the subgraph generation in step S3, and the feature aggregation calculation logic in step S4 are encapsulated into independently running WebWorker background threads. The main thread, i.e., the UI rendering thread, is only responsible for listening to user component change events and receiving JSON-formatted verification result data returned by the background thread. Through this architecture design that separates computation and rendering, even when the background is performing complex graph convolution operations or traversing large-scale dependency closures, the canvas operations of the low-code designer, including component dragging, scaling, and attribute configuration, can still maintain a high smoothness of 60 frames per second, thereby truly achieving a non-blocking real-time incremental verification experience.

[0111] Specifically, to ensure the interpretability of the verification results, the system obtains the attention coefficient matrix generated by the heterogeneous graph neural network during the forward propagation calculation of feature aggregation on representative nodes. This matrix is ​​parsed to extract the weight values ​​of the edges between representative nodes and their neighboring nodes, and then sorted in descending order. Edges with weight values ​​at the top of a preset interval are identified as causative edges, and the neighboring nodes connected by these causative edges are identified as causative nodes. Based on the mapping relationship constructed in step S1, the corresponding visual primitives of the causative nodes are located in the low-code designer interface, and a heatmap layer or highlighted rendering path is generated based on the weight values. For example, a highlighted red line is used to mark the specific logical jump connection that leads to the infinite loop, thereby helping developers quickly understand the root cause of the defect.

[0112] Example 3, referring to Figure 5 As one embodiment of the present invention, a training method for constructing the graph reasoning model is provided, which is pre-executed before the low-code meta-model incremental verification system is started, aiming to give the model the ability to identify business logic defects.

[0113] S10: Build a pre-built defect library.

[0114] To address the problem of insufficient training samples due to the scarcity of real-world defect data in the low-code domain, this embodiment employs an adversarial generation strategy based on a dual-constraint mechanism to construct a high-quality defect library, ensuring that the generated samples conform to the actual logic of the underlying runtime architecture. Specifically, it includes the following sub-steps: S11: Construct the first layer of constraints, namely physical constraints based on the underlying operating architecture topology.

[0115] First, the underlying runtime architecture topology of the low-code platform is constructed, defining the architecture connectivity permission rules between different network security domains and components. In the specific implementation, this topology is defined as a... Architecture adjacency matrix ,in The number of network security zones. For example, set... For the front-end browser domain, DMZ area This is the core data field. Matrix elements. Indicates the area With the region Network communication is allowed between them. This indicates architectural isolation.

[0116] The generator queries this matrix when attempting to generate negative samples involving cross-network security domain interactions. For example, when constructing a scenario where a front-end web component directly connects to a core financial database via JDBC, due to... The system will determine that the connection path to be constructed is unreachable at the underlying operating architecture, and thus directly block the generation of the invalid sample through a masking mechanism to avoid generating meaningless noise data.

[0117] S12: Construct the second layer of constraints, namely logical constraints based on metadata type validation.

[0118] When generating negative samples involving performance configuration, a rigorous type suitability check is performed. First, the target component node to be injected with the defect is selected in the negative sample subgraph, and the upstream data source of the component is traced back using virtual semantic edges. Then, the data type definition is obtained by parsing the metadata of the upstream data source.

[0119] The injection of defects is executed in two ways: First, if the upstream data type is identified as a collection type or a frequently accessed object, it indicates that the component has the prerequisite for batch processing or caching optimization. The system allows the "Enable Batch Processing" or "Enable Caching" attribute of the target node to be executed with a logical negation operation, thereby successfully generating an implicit performance defect sample that causes page lag under large data volume; Second, if the upstream data type is only a string or a boolean value, and it is identified that there is no batch processing requirement for this type, the system will automatically skip the injection of such defects into the node to avoid generating a logically invalid sample such as "disable batch processing for single-line text".

[0120] S13: Construction of defect samples based on dual constraints.

[0121] After passing the above verification, this embodiment specifically constructs the following two types of defects: Type 1: Pattern-Driven Semantic Flipping. This approach maintains the physical topology of the subgraph while perturbing the metadata schema definition. For example, it disables the "masked display" attribute for sensitive fields, generating adversarial examples that are syntactically valid but pose a risk of business logic leakage.

[0122] Type 2: Context Misalignment and Unauthorized Access Construction. This involves using virtual semantic edges to construct runtime environment context migrations. For example, modifying an API call connection that originally pointed to a high-privilege internal management domain to a simulated interface pointing to a low-privilege public internet domain; or directly binding a data entity field marked "visible only to administrators" to a page component "accessible to anonymous visitors," thus constructing unauthorized access risk samples.

[0123] Finally, the generated negative sample subgraphs are input into the heterogeneous graph neural network, and the encoder of the main model is reused to generate negative sample embedding vectors. They are then stored in a pre-set defect library for use in subsequent comparative learning of negative examples.

[0124] S20: Construct a graph reasoning model and perform contrastive learning pre-training.

[0125] In order to enable heterogeneous graph neural networks to recognize component structures that have different syntax but the same function, this embodiment uses graph data augmentation technology and contrastive learning objective function for optimization during the pre-training stage.

[0126] S21: Perform graph data augmentation to generate positive sample pairs.

[0127] For a baseline subgraph The semantic equivalence graph is generated using the following strategy. : Strategy 1: Node attribute occlusion. Randomly occlude non-critical attributes, such as background color and font size, thereby forcing the model to focus on core business attributes.

[0128] Strategy 2: Structural perturbation. Without changing the graph's connectivity, randomly add or remove some redundant virtual edges.

[0129] Strategy 3: Random cropping. Extract local subgraphs with different radii centered on the target node.

[0130] During training, As positive sample pairs, they are input into the model to maximize the similarity of their embedding vectors, with the aim of teaching the model to ignore irrelevant user interface noise and focus on the essence of the business logic.

[0131] S22: Optimize model parameters based on triplet loss function.

[0132] This embodiment preferably uses a triplet loss function to optimize the heterogeneous graph neural network: in, For anchor point samples, i.e., the embedding vectors of the current normal component subgraph, Positive samples are the embedding vectors of semantically equivalent subgraphs generated through data augmentation. For negative samples, that is, the embedding vectors of known defect subgraphs extracted from a pre-set defect library. It is the Euclidean distance function. This is the preset interval threshold.

[0133] like Figure 5 As shown in the simulation experiment, during the training process based on the triplet loss function, as the loss value (red line) decreases, the defect detection F1-Score (blue dashed line) increases. The negative samples generated based on the dual physical and logical constraints effectively support the model convergence.

[0134] The loss function model optimizes parameters through gradient descent, aiming to bring the embedding vectors of normal designs and their semantically equivalent variants closer together in the feature space, while pushing the embedding vectors of normal designs and defective designs further apart, thereby forming a clear decision boundary in the vector space, enabling subsequent incremental verification to accurately identify defects based on distance metrics.

[0135] Example 4 illustrates a method for incremental verification of low-code meta-models. It should be noted that the technical solution of this low-code meta-model incremental verification system belongs to the same concept as the technical solution of the aforementioned low-code meta-model incremental verification method. Details not described in detail in this example can be found in the description of the technical solution of the aforementioned low-code meta-model incremental verification method.

[0136] This embodiment also provides a system for incremental verification of low-code metamodels, including: The graph structure construction module is used to parse the low-code application model and construct graph structure data to represent the relationships between components. The graph structure data includes physical connection relationships that reflect the physical hierarchy of components, as well as virtual semantic connection relationships constructed based on the semantic dependencies between components. The index building module is used to build a metadata dependency index based on the virtual semantic connection relationship; The incremental subgraph generation module is used to respond to the change operation of at least one component in the low-code application model, obtain the reverse dependency closure that has a dependency relationship with the at least one component based on the metadata dependency index, and extract the neighborhood context in combination with the physical connection relationship to generate an incremental subgraph to be verified with a limited verification scope. The feature reasoning mapping module is used to aggregate structurally equivalent component nodes based on the incremental subgraph to be verified, select representative nodes to input the graph reasoning model, generate high-dimensional feature vectors representing business logic, and map the high-dimensional feature vectors to the structurally equivalent component nodes. The verification analysis module is used to calculate the similarity between the high-dimensional feature vector and the preset defect feature vector, output verification conclusions based on the similarity calculation results, and associate them with repair strategies. The model training module is used to collect historical low-code application models to construct a sample graph dataset, perform random graph data augmentation transformation on the sample graphs in the sample graph dataset to generate semantically consistent augmented views, and form positive sample pairs with the sample graphs; randomly sample heterogeneous nodes without topological association from the sample graph dataset to form negative sample pairs; and optimize the parameters of the graph inference model based on the contrastive learning objective function.

[0137] This embodiment also provides an electronic device applicable to a method for incremental verification of a low-code meta-model, comprising: a memory and a processor; the memory is used to store computer-executable instructions, and the processor is used to execute the computer-executable instructions to implement the method for incremental verification of a low-code meta-model as proposed in the above embodiment.

[0138] This embodiment also provides a storage medium on which a computer program is stored, which, when executed by a processor, implements a method for incremental verification of a low-code meta-model as proposed in the above embodiments.

[0139] The storage medium proposed in this embodiment and the method for implementing incremental verification of a low-code meta-model proposed in the above embodiments belong to the same inventive concept. Technical details not described in detail in this embodiment can be found in the above embodiments, and this embodiment has the same beneficial effects as the above embodiments.

[0140] Based on the above description of the implementation methods, those skilled in the art can clearly understand that the present invention can be implemented using software and necessary general-purpose hardware, and of course, it can also be implemented using hardware, but in many cases the former is a better implementation method. Based on this understanding, the technical solution of the present invention, or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, such as a computer floppy disk, read-only memory (ROM), random access memory (RAM), flash memory, hard disk, or optical disk, etc., including several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods of the various embodiments of the present invention.

[0141] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that the technical solutions of the present invention can be modified or equivalently replaced without departing from the spirit and scope of the technical solutions of the present invention, and all such modifications or substitutions should be covered within the scope of the claims of the present invention.

Claims

1. A method for incremental verification of a low-code metamodel, characterized in that: include, The low-code application model is parsed, and a graph structure data is constructed to represent the relationships between components. The graph structure data includes physical connection relationships that reflect the physical hierarchy of components, as well as virtual semantic connection relationships constructed based on the semantic dependencies between components. A metadata dependency index is constructed based on the aforementioned virtual semantic connection relationship; In response to a change operation of at least one component in the low-code application model, the reverse dependency closure that has a dependency relationship with the at least one component is obtained based on the metadata dependency index, and the neighborhood context is extracted in combination with the physical connection relationship to generate an incremental subgraph to be verified with a limited verification scope. Based on the incremental subgraph to be verified, aggregate structurally equivalent component nodes, select representative nodes to input the graph inference model, generate high-dimensional feature vectors representing business logic, and map the high-dimensional feature vectors to the structurally equivalent component nodes. Calculate the similarity between the high-dimensional feature vector and the preset defect feature vector, output the verification conclusion based on the similarity calculation result, and associate it with the repair strategy.

2. The method for incremental verification of a low-code metamodel as described in claim 1, characterized in that: The graph structure data used to characterize component relationships includes: Define the range of node types for the graph structure data. The range of node types includes multi-level metadata entities that constitute a low-code application. The multi-level includes presentation layer elements and business function elements. Extract the hierarchical nesting structure of the presentation layer elements and directly map the hierarchical nesting structure to the physical connection relationship; The configuration attributes of the presentation layer elements are parsed, the reference associations pointing to the business function elements in the configuration attributes are extracted, and the topological distance in the physical hierarchy is ignored. A directed connection is directly established between the two as the virtual semantic connection relationship.

3. The method for incremental verification of a low-code metamodel as described in claim 1, characterized in that: The generation of the incremental subgraph to be verified within the defined verification range includes: Configure the metadata dependency index as a reverse mapping structure that records reference relationships; Based on the reverse mapping structure, components that have explicit attribute bindings to at least one component and components that have implicit data flow dependencies are retrieved to form the reverse dependency closure, and the components in the reverse dependency closure are defined as core nodes. Based on the physical connection relationship, at least one-order physical neighborhood is extended with the core node as the center, and the components within the physical neighborhood are used as the neighborhood context. The local topology structure consisting of the core node, the neighborhood context, and the connection relationships between the core node and the neighborhood context is extracted and used as the incremental subgraph to be verified.

4. The method for incremental verification of a low-code metamodel as described in claim 1, characterized in that: The component nodes equivalent to the aggregation structure include: Extract the component attribute features and topological connection features of the constituent nodes contained in the local incremental subgraph model to be verified, and serialize the component attribute features and topological connection features into structural feature fingerprints that uniquely identify the nodes; The constituent nodes are divided based on the structural feature fingerprint to construct at least one topological equivalence set, and the representative node is determined from the topological equivalence set; After obtaining the high-dimensional feature vector of the representative node through the graph reasoning model, a feature reuse mapping is established from the representative node to the other nodes in the topological equivalence set to complete the batch feature update of the topological equivalence set.

5. The method for incremental verification of a low-code metamodel as described in claim 1, characterized in that: The high-dimensional feature vectors of the generated representation business logic include: Parse the verification task instructions to identify the target dimension emphasized by the current verification task. The target dimension includes the interface structure dimension and the business logic dimension. The weight parameters of the task-aware attention mechanism integrated into the graph reasoning model are configured differently based on the target dimension. In response to the target dimension being the interface structure dimension, the aggregation weight ratio of the physical connection relationship is increased to exceed that of the virtual semantic connection relationship; In response to the target dimension being the business logic dimension, the aggregation weight ratio of the virtual semantic connection relationship is increased to exceed that of the physical connection relationship.

6. The method for incremental verification of a low-code metamodel as described in claim 1, characterized in that: The calculation of the similarity between the high-dimensional feature vector and the preset defect feature vector, the output of verification conclusions based on the similarity calculation results, and the association of remediation strategies include: A defect pattern library is constructed, which records the correspondence between the defect feature vectors, defect type identifiers, and repair suggestions; Calculate the similarity value between the high-dimensional feature vector and each of the defect feature vectors in the defect pattern library; Target defect feature vectors with similarity values ​​exceeding a preset judgment threshold are selected, and the defect type identifiers that correspond to the target defect feature vectors are identified as verification conclusions. Based on the correspondence, the repair suggestions are extracted, and the repair strategy is output.

7. The method for incremental verification of a low-code metamodel as described in claim 1, characterized in that, It also includes the training steps for constructing the graph reasoning model: Collect historical low-code application models to construct a sample graph dataset; Perform random graph data augmentation transformation on the sample graphs in the sample graph dataset to generate semantically consistent augmented views, and then form positive sample pairs with the sample graphs; Randomly sample heterogeneous nodes with no topological association from the sample graph dataset to form negative sample pairs; The parameters of the graph inference model are optimized based on the contrastive learning objective function, which drives the graph inference model to map the feature vectors of the positive sample pairs to the neighborhood space and the feature vectors of the negative sample pairs to the estrangement space.

8. A system for incremental verification of a low-code metamodel, employing a method for incremental verification of a low-code metamodel as described in any one of claims 1 to 7, characterized in that, include: The graph structure construction module is used to parse the low-code application model and construct graph structure data to represent the relationships between components. The graph structure data includes physical connection relationships that reflect the physical hierarchy of components, as well as virtual semantic connection relationships constructed based on the semantic dependencies between components. The index building module is used to build a metadata dependency index based on the virtual semantic connection relationship; The incremental subgraph generation module is used to respond to the change operation of at least one component in the low-code application model, obtain the reverse dependency closure that has a dependency relationship with the at least one component based on the metadata dependency index, and extract the neighborhood context in combination with the physical connection relationship to generate an incremental subgraph to be verified with a limited verification scope. The feature reasoning mapping module is used to aggregate structurally equivalent component nodes based on the incremental subgraph to be verified, select representative nodes to input the graph reasoning model, generate high-dimensional feature vectors representing business logic, and map the high-dimensional feature vectors to the structurally equivalent component nodes. The verification analysis module is used to calculate the similarity between the high-dimensional feature vector and the preset defect feature vector, output verification conclusions based on the similarity calculation results, and associate them with repair strategies. The model training module is used to collect historical low-code application models to build a sample graph dataset.

9. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the steps of a method for incremental verification of a low-code metamodel according to any one of claims 1 to 7.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the steps of a method for incremental verification of a low-code metamodel according to any one of claims 1 to 7.

Images