fix: correctly handle route schema defaults with Konnect

Kong Gateway supports different schemas for different router versions.
On the other hand, Konnect can support only one schema including all
fields from 'traditional' and 'expressions' router schemas.
This may be problematic when it comes to defaults injection, because
the defaults for the 'traditiona' router schema can be wrongly injected
into the 'expressions' route configuration.

Here we make sure that only the fields that are supported for a given
router version are set in the route configuration.

pkg/file/builder.go

@@ -1110,11 +1110,37 @@ func (b *stateBuilder) ingestRoute(r FRoute) error {
 		return err
 	}
 	r.Route.StripPath = stripPath
+
+	hasExpression := r.Route.Expression != nil
+	hasRegexPriority := r.Route.RegexPriority != nil
+	hasPathHandling := r.Route.PathHandling != nil
+
 	b.defaulter.MustSet(&r.Route)
 	if route != nil {
 		r.Route.CreatedAt = route.CreatedAt
 	}
 
+	// Kong Gateway supports different schemas for different router versions.
+	// On the other hand, Konnect can support only one schema including all
+	// fields from 'traditional' and 'expressions' router schemas.
+	// This may be problematic when it comes to defaults injection, because
+	// the defaults for the 'traditiona' router schema can be wrongly injected
+	// into the 'expressions' route configuration.
+	//
+	// Here we make sure that only the fields that are supported for a given
+	// router version are set in the route configuration.
+	if b.isKonnect && hasExpression && !(hasRegexPriority || hasPathHandling) {
+		if r.Route.PathHandling != nil {
+			r.Route.PathHandling = nil
+		}
+		if r.Route.RegexPriority != nil {
+			r.Route.RegexPriority = nil
+		}
+		if r.Route.Priority == nil {
+			r.Route.Priority = kong.Uint64(0)
+		}
+	}
+
 	b.rawState.Routes = append(b.rawState.Routes, &r.Route)
 	err = b.intermediate.Routes.Add(state.Route{Route: r.Route})
 	if err != nil {

pkg/file/builder_test.go

@@ -2755,3 +2755,93 @@ func Test_getStripPathBasedOnProtocols(t *testing.T) {
 		})
 	}
 }
+
+func Test_stateBuilder_ingestRouteKonnect(t *testing.T) {
+	assert := assert.New(t)
+	rand.Seed(42)
+	type fields struct {
+		currentState *state.KongState
+	}
+	type args struct {
+		route FRoute
+	}
+	tests := []struct {
+		name      string
+		fields    fields
+		args      args
+		wantErr   bool
+		wantState *utils.KongRawState
+	}{
+		{
+			name: "traditional route",
+			fields: fields{
+				currentState: emptyState(),
+			},
+			args: args{
+				route: FRoute{
+					Route: kong.Route{
+						Name: kong.String("foo"),
+					},
+				},
+			},
+			wantErr: false,
+			wantState: &utils.KongRawState{
+				Routes: []*kong.Route{
+					{
+						ID:            kong.String("538c7f96-b164-4f1b-97bb-9f4bb472e89f"),
+						Name:          kong.String("foo"),
+						PreserveHost:  kong.Bool(false),
+						RegexPriority: kong.Int(0),
+						StripPath:     kong.Bool(false),
+						Protocols:     kong.StringSlice("http", "https"),
+					},
+				},
+			},
+		},
+		{
+			name: "expression route",
+			fields: fields{
+				currentState: emptyState(),
+			},
+			args: args{
+				route: FRoute{
+					Route: kong.Route{
+						Name:       kong.String("foo"),
+						Expression: kong.String(`'(http.path == "/test") || (http.path ^= "/test/")'`),
+					},
+				},
+			},
+			wantErr: false,
+			wantState: &utils.KongRawState{
+				Routes: []*kong.Route{
+					{
+						ID:           kong.String("5b1484f2-5209-49d9-b43e-92ba09dd9d52"),
+						Name:         kong.String("foo"),
+						PreserveHost: kong.Bool(false),
+						Expression:   kong.String(`'(http.path == "/test") || (http.path ^= "/test/")'`),
+						Priority:     kong.Uint64(0),
+						StripPath:    kong.Bool(false),
+						Protocols:    kong.StringSlice("http", "https"),
+					},
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.Background()
+			b := &stateBuilder{
+				currentState: tt.fields.currentState,
+				isKonnect:    true,
+			}
+			b.rawState = &utils.KongRawState{}
+			d, _ := utils.GetDefaulter(ctx, defaulterTestOpts)
+			b.defaulter = d
+			b.intermediate, _ = state.NewKongState()
+			if err := b.ingestRoute(tt.args.route); (err != nil) != tt.wantErr {
+				t.Errorf("stateBuilder.ingestRoute() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			assert.Equal(tt.wantState, b.rawState)
+		})
+	}
+}