Block execution of multiple mutation operations

Author: daniel-chambers

ndc-lambda-sdk/src/execution.ts

@@ -41,15 +41,16 @@ export async function executeQuery(queryRequest: sdk.QueryRequest, functionsSche
 }
 
 export async function executeMutation(mutationRequest: sdk.MutationRequest, functionsSchema: schema.FunctionsSchema, runtimeFunctions: RuntimeFunctions): Promise<sdk.MutationResponse> {
-  const operationResults: sdk.MutationOperationResults[] = [];
+  if (mutationRequest.operations.length > 1)
+    throw new sdk.NotSupported("Transactional mutations (multiple operations) are not supported");
+  if (mutationRequest.operations.length <= 0)
+    throw new sdk.BadRequest("One mutation operation must be provided")
 
-  for (const mutationOperation of mutationRequest.operations) {
-    const result = await executeMutationOperation(mutationOperation, functionsSchema, runtimeFunctions);
-    operationResults.push(result);
-  }
+  const mutationOperation = mutationRequest.operations[0]!;
+  const result = await executeMutationOperation(mutationOperation, functionsSchema, runtimeFunctions);
 
   return {
-    operation_results: operationResults
+    operation_results: [result]
   };
 }
 

ndc-lambda-sdk/test/execution/execute-mutation.test.ts

@@ -42,7 +42,7 @@ describe("execute mutation", function() {
         "String": {}
       }
     };
-    const queryRequest: sdk.MutationRequest = {
+    const mutationRequest: sdk.MutationRequest = {
       operations: [
         {
           type: "procedure",
@@ -56,7 +56,7 @@ describe("execute mutation", function() {
       collection_relationships: {}
     };
 
-    const result = await executeMutation(queryRequest, functionSchema, runtimeFunctions);
+    const result = await executeMutation(mutationRequest, functionSchema, runtimeFunctions);
     assert.deepStrictEqual(result, {
       operation_results: [
         {
@@ -70,6 +70,70 @@ describe("execute mutation", function() {
     assert.equal(functionCallCount, 1);
   });
 
+  it("blocks execution of multiple operations", async function() {
+    let functionCallCount = 0;
+    const runtimeFunctions = {
+      "theFunction": (param: string) => {
+        functionCallCount++;
+        return `First function called with '${param}'`;
+      }
+    };
+    const functionSchema: FunctionsSchema = {
+      functions: {
+        "theFunction": {
+          ndcKind: FunctionNdcKind.Procedure,
+          description: null,
+          parallelDegree: null,
+          arguments: [
+            {
+              argumentName: "param",
+              description: null,
+              type: {
+                type: "named",
+                kind: "scalar",
+                name: "String"
+              }
+            },
+          ],
+          resultType: {
+            type: "named",
+            kind: "scalar",
+            name: "String"
+          }
+        }
+      },
+      objectTypes: {},
+      scalarTypes: {
+        "String": {}
+      }
+    };
+    const mutationRequest: sdk.MutationRequest = {
+      operations: [
+        {
+          type: "procedure",
+          name: "theFunction",
+          fields: {},
+          arguments: {
+            "param": "test"
+          }
+        },
+        {
+          type: "procedure",
+          name: "theFunction",
+          fields: {},
+          arguments: {
+            "param": "test2"
+          }
+        }
+      ],
+      collection_relationships: {}
+    };
+
+    await expect(executeMutation(mutationRequest, functionSchema, runtimeFunctions))
+        .to.be.rejectedWith(sdk.NotSupported, "Transactional mutations (multiple operations) are not supported");
+    assert.equal(functionCallCount, 0);
+  });
+
   describe("function error handling", function() {
     const functionSchema: FunctionsSchema = {
       functions: {