BackwardsCompatible -> BackCompat

Author: krishnangovindraj

src/framework/graph-visualiser/converter.ts

@@ -22,17 +22,17 @@ import {
 import {ILogicalGraphConverter} from "./visualisation";
 import {StudioConverterStructureParameters, StudioConverterStyleParameters} from "./config";
 import {
-    AnalyzedPipelineBackwardsCompatible,
-    backwardCompatible_expressionAssigned,
-    ConstraintBackwardsCompatible
+    AnalyzedPipelineBackCompat,
+    backCompat_expressionAssigned,
+    ConstraintBackCompat
 } from "./index";
 
 type ConstraintVertexOrSpecial = ConstraintVertexAny | VertexFunction | VertexExpression;
 
 export class StudioConverter implements ILogicalGraphConverter {
 
     constructor(
-        public readonly graph: VisualGraph, public readonly queryStructure: AnalyzedPipelineBackwardsCompatible,
+        public readonly graph: VisualGraph, public readonly queryStructure: AnalyzedPipelineBackCompat,
         public readonly isFollowupQuery: boolean, public readonly structureParameters: StudioConverterStructureParameters,
         public readonly styleParameters: StudioConverterStyleParameters
     ) {
@@ -213,7 +213,7 @@ export class StudioConverter implements ILogicalGraphConverter {
             vertex_map_key: expressionVertexKey
         }
 
-        let queryVertex = backwardCompatible_expressionAssigned(constraint.queryConstraint);
+        let queryVertex = backCompat_expressionAssigned(constraint.queryConstraint);
         let varNameOrId = getVariableName(this.queryStructure, queryVertex) ?? `$_${queryVertex.id}`;
         let label = `assign[${varNameOrId}]`;
         this.maybeCreateEdge(answerIndex, constraint, label, expressionVertex, expression.assigned, expressionVertex, queryVertex);
@@ -256,15 +256,15 @@ export class StudioConverter implements ILogicalGraphConverter {
     }
 }
 
-export function shouldCreateNode(structure: AnalyzedPipelineBackwardsCompatible, vertex: ConstraintVertexOrSpecial) {
+export function shouldCreateNode(structure: AnalyzedPipelineBackCompat, vertex: ConstraintVertexOrSpecial) {
     return !(
         (vertex.tag === "label" ||
             (vertex.tag == "variable" && !structure.outputs.includes(vertex.id))
         )
     );
 }
 
-export function shouldCreateEdge(structure: AnalyzedPipelineBackwardsCompatible, _edge: ConstraintBackwardsCompatible, from: ConstraintVertexOrSpecial, to: ConstraintVertexOrSpecial) {
+export function shouldCreateEdge(structure: AnalyzedPipelineBackCompat, _edge: ConstraintBackCompat, from: ConstraintVertexOrSpecial, to: ConstraintVertexOrSpecial) {
     return shouldCreateNode(structure, from) && shouldCreateNode(structure, to);
 }
 

src/framework/graph-visualiser/graph.ts

@@ -9,11 +9,11 @@ import {
 } from "@typedb/driver-http";
 import {MultiGraph} from "graphology";
 import {
-    ConstraintBackwardsCompatible,
-    ConceptRowsQueryResponseBackwardsCompatible,
-    backwardCompatible_expressionAssigned,
-    backwardCompatible_pipelineBlocks,
-    AnalyzedPipelineBackwardsCompatible
+    ConstraintBackCompat,
+    ConceptRowsQueryResponseBackCompat,
+    backCompat_expressionAssigned,
+    backCompat_pipelineBlocks,
+    AnalyzedPipelineBackCompat
 } from "./index";
 
 ///////////////////////
@@ -262,19 +262,19 @@ export const newVisualGraph: () => VisualGraph = () => new MultiGraph<VertexAttr
 ///////////////////////////////////
 // TypeDB server -> logical graph
 ///////////////////////////////////
-export function constructGraphFromRowsResult(rows_result: ConceptRowsQueryResponseBackwardsCompatible): DataGraph {
+export function constructGraphFromRowsResult(rows_result: ConceptRowsQueryResponseBackCompat): DataGraph {
     return new LogicalGraphBuilder().build(rows_result);
 }
 
 class LogicalGraphBuilder {
     constructor() {
     }
 
-    build(rows_result: ConceptRowsQueryResponseBackwardsCompatible): DataGraph {
+    build(rows_result: ConceptRowsQueryResponseBackCompat): DataGraph {
         let answers: DataConstraintAny[][] = [];
         rows_result.answers.forEach((row, answerIndex) => {
             let current_answer_edges = row.involvedBlocks!.flatMap(branchIndex => {
-                return backwardCompatible_pipelineBlocks(rows_result.query!)[branchIndex].constraints.map((constraint, constraintIndex) => {
+                return backCompat_pipelineBlocks(rows_result.query!)[branchIndex].constraints.map((constraint, constraintIndex) => {
                     return this.toDataConstraint(rows_result.query!, answerIndex, constraint, row.data, {
                         branch: branchIndex,
                         constraint: constraintIndex
@@ -286,7 +286,7 @@ class LogicalGraphBuilder {
         return {answers: answers};
     }
 
-    translate_vertex(structure: AnalyzedPipelineBackwardsCompatible, structure_vertex: ConstraintVertexAny, answerIndex: number, data: ConceptRow): DataVertex {
+    translate_vertex(structure: AnalyzedPipelineBackCompat, structure_vertex: ConstraintVertexAny, answerIndex: number, data: ConceptRow): DataVertex {
         switch (structure_vertex.tag) {
             case "variable": {
                 let name = getVariableName(structure, structure_vertex);
@@ -316,7 +316,7 @@ class LogicalGraphBuilder {
         }
     }
 
-    private toDataConstraint(structure: AnalyzedPipelineBackwardsCompatible, answerIndex: number, constraint: ConstraintBackwardsCompatible, data: ConceptRow, coordinates: QueryCoordinates): DataConstraintAny | null{
+    private toDataConstraint(structure: AnalyzedPipelineBackCompat, answerIndex: number, constraint: ConstraintBackCompat, data: ConceptRow, coordinates: QueryCoordinates): DataConstraintAny | null{
         switch (constraint.tag) {
             case "isa": {
                 return {
@@ -419,7 +419,7 @@ class LogicalGraphBuilder {
                 }
             }
             case "expression": {
-                const queryAssigned = backwardCompatible_expressionAssigned(constraint);
+                const queryAssigned = backCompat_expressionAssigned(constraint);
                 return {
                     tag: "expression",
                     textSpan: constraint.textSpan,

src/framework/graph-visualiser/index.ts

@@ -109,7 +109,7 @@ export class GraphVisualiser {
         return this.getColorForConstraintIndex(branchIndex, constraintIndex);
     }
 
-    colorQuery(queryString: string, queryStructure: AnalyzedPipelineBackwardsCompatible): string {
+    colorQuery(queryString: string, queryStructure: AnalyzedPipelineBackCompat): string {
         function shouldColourConstraint(constraint: ConstraintAny | ConstraintExpressionLegacy | ConstraintLinksLegacy): boolean {
             switch (constraint.tag) {
                 case "isa": return shouldCreateEdge(queryStructure, constraint, constraint.instance, constraint.type);
@@ -131,7 +131,7 @@ export class GraphVisualiser {
 
                     return (
                         constraint.arguments.map(arg => shouldCreateNode(queryStructure, arg)).reduce((a,b) => a || b, false)
-                        || shouldCreateNode(queryStructure, backwardCompatible_expressionAssigned(constraint))
+                        || shouldCreateNode(queryStructure, backCompat_expressionAssigned(constraint))
                     );
                 case "functionCall":
                     return (
@@ -151,7 +151,7 @@ export class GraphVisualiser {
         }
         let spans: { span: ConstraintSpan, coordinates: QueryCoordinates}[] = [];
 
-        backwardCompatible_pipelineBlocks(queryStructure).forEach((branch, branchIndex) => {
+        backCompat_pipelineBlocks(queryStructure).forEach((branch, branchIndex) => {
             branch.constraints.forEach((constraint, constraintIndex) => {
                 if (shouldColourConstraint(constraint)) {
                     let span = "textSpan" in constraint ? constraint["textSpan"] : null;
@@ -205,7 +205,7 @@ export function createSigmaRenderer(containerEl: HTMLElement, sigma_settings: Si
     return new Sigma(graph, containerEl, sigma_settings);
 }
 
-export function backwardCompatible_pipelineBlocks(pipeline : AnalyzedPipelineBackwardsCompatible): AnalyzedConjunction[] | QueryConjunctionLegacy[] {
+export function backCompat_pipelineBlocks(pipeline : AnalyzedPipelineBackCompat): AnalyzedConjunction[] | QueryConjunctionLegacy[] {
     if ("blocks" in pipeline) {
         return pipeline["blocks"];
     } else if ("conjunctions" in pipeline) {
@@ -215,10 +215,10 @@ export function backwardCompatible_pipelineBlocks(pipeline : AnalyzedPipelineBac
     }
 }
 
-export function backwardCompatible_expressionAssigned(expr: ConstraintExpression | ConstraintExpressionLegacy): ConstraintVertexVariable {
+export function backCompat_expressionAssigned(expr: ConstraintExpression | ConstraintExpressionLegacy): ConstraintVertexVariable {
     return (Array.isArray(expr.assigned) ? expr.assigned[0] : expr.assigned) as ConstraintVertexVariable;
 }
 
-export type ConstraintBackwardsCompatible = ConstraintAny | ConstraintLinksLegacy | ConstraintExpressionLegacy;
-export type ConceptRowsQueryResponseBackwardsCompatible = ConceptRowsQueryResponse | ConceptRowsQueryResponseLegacy;
-export type AnalyzedPipelineBackwardsCompatible = AnalyzedPipeline | QueryStructureLegacy;
+export type ConstraintBackCompat = ConstraintAny | ConstraintLinksLegacy | ConstraintExpressionLegacy;
+export type ConceptRowsQueryResponseBackCompat = ConceptRowsQueryResponse | ConceptRowsQueryResponseLegacy;
+export type AnalyzedPipelineBackCompat = AnalyzedPipeline | QueryStructureLegacy;