add temporary mutation tets

example/reference/connector.go

@@ -341,11 +341,64 @@ func executeProcedure(ctx context.Context, state *State, collectionRelationship
 			AffectedRows: 1,
 			Returning:    []map[string]any{row},
 		}, nil
+	case "delete_articles":
+		return executeDeleteArticles(state, operation.Arguments, operation.Fields, collectionRelationship)
 	default:
 		return nil, schema.BadRequestError("unknown procedure", nil)
 	}
 }
 
+func executeDeleteArticles(
+	state *State,
+	arguments json.RawMessage,
+	fields map[string]schema.Field,
+	collectionRelationships map[string]schema.Relationship,
+) (*schema.MutationOperationResults, error) {
+	var argumentData struct {
+		Where schema.Expression `json:"where"`
+	}
+	if err := json.Unmarshal(arguments, &argumentData); err != nil {
+		return nil, schema.BadRequestError(err.Error(), nil)
+	}
+	if len(argumentData.Where) == 0 {
+		return nil, schema.BadRequestError("Expected argument 'where'", nil)
+	}
+
+	var removed []map[string]any
+	for _, article := range state.Articles {
+		encodedArticle, err := schema.EncodeRow(article)
+		if err != nil {
+			return nil, schema.InternalServerError(err.Error(), nil)
+		}
+
+		ok, err := evalExpression(nil, nil, state, argumentData.Where, encodedArticle, encodedArticle)
+		if err != nil {
+			return nil, err
+		}
+		if ok {
+			removed = append(removed, encodedArticle)
+		}
+	}
+
+	var returning []map[string]any
+	for _, item := range removed {
+		row, err := evalRow(fields, collectionRelationships, nil, state, item)
+		if err != nil {
+			return nil, err
+		}
+		returning = append(returning, row)
+	}
+
+	return &schema.MutationOperationResults{
+		AffectedRows: len(returning),
+		Returning: []map[string]any{
+			{
+				"__value": returning,
+			},
+		},
+	}, nil
+}
+
 func executeQueryWithVariables(
 	collection string,
 	arguments map[string]schema.Argument,

example/reference/connector_test.go

@@ -27,7 +27,7 @@ func createTestServer(t *testing.T) *connector.Server[RawConfiguration, Configur
 	return server
 }
 
-func fetchTestSample[R any](t *testing.T, uri string) *http.Response {
+func fetchTestSample(t *testing.T, uri string) *http.Response {
 	res, err := http.Get(uri)
 	if err != nil {
 		t.Errorf("failed to fetch test sample at %s: %s", uri, err)
@@ -235,13 +235,13 @@ func TestQuery(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			req := fetchTestSample[schema.QueryRequest](t, tc.requestURL)
+			req := fetchTestSample(t, tc.requestURL)
 			var expected schema.QueryResponse
 			var err error
 			if len(tc.response) > 0 {
 				err = json.Unmarshal(tc.response, &expected)
 			} else {
-				expectedRes := fetchTestSample[schema.QueryResponse](t, tc.responseURL)
+				expectedRes := fetchTestSample(t, tc.responseURL)
 				err = json.NewDecoder(expectedRes.Body).Decode(&expected)
 			}
 			if err != nil {
@@ -259,3 +259,40 @@ func TestQuery(t *testing.T) {
 		})
 	}
 }
+
+func TestMutation(t *testing.T) {
+	server := createTestServer(t).BuildTestServer()
+
+	testCases := []struct {
+		name        string
+		requestURL  string
+		responseURL string
+		response    []byte
+	}{}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			req := fetchTestSample(t, tc.requestURL)
+			var expected schema.MutationResponse
+			var err error
+			if len(tc.response) > 0 {
+				err = json.Unmarshal(tc.response, &expected)
+			} else {
+				expectedRes := fetchTestSample(t, tc.responseURL)
+				err = json.NewDecoder(expectedRes.Body).Decode(&expected)
+			}
+			if err != nil {
+				t.Errorf("failed to decode expected response: %s", err)
+				t.FailNow()
+			}
+
+			res, err := http.Post(fmt.Sprintf("%s/mutation", server.URL), "application/json", req.Body)
+			if err != nil {
+				t.Errorf("expected no error, got %s", err)
+				t.FailNow()
+			}
+
+			assertHTTPResponse[schema.MutationResponse](t, res, http.StatusOK, expected)
+		})
+	}
+}