<!-- Love localstack? Please consider supporting our collective:
👉  https://opencollective.com/localstack/donate -->

# Type of request: This is a ...

- [x] bug report

# Detailed description

DynamoDb service for some reason returns 500 with an empty-json-object body when sending
`TransactWriteItems` with `ConditionCheck` and some other write operation.
I have verified this behaviour with single `ConditionCheck` in `TransactItems` and it works, but with any of ther `Put, Update, Delete` operations in the transaction it fails...

## Expected behavior

It should not return an error, but it does.
I checked against dynamodb local with:
```
docker run --rm -p 8000:8000 amazon/dynamodb-local
```
And it works, but localstack's dynamodb doesnt...

## Actual behavior

It returns an unhelpful 500 response with empty json object (see Rust SDK output)

# Steps to reproduce

Start localstack, wait until it is up and running and run any of JavaScript or Rust snippets bellow.

## Command used to start LocalStack

```
localstack start
```

## Client code (AWS SDK code snippet, or sequence of "awslocal" commands)
JavaScript SDK gives little information about the underlying error, but it is less code:
<details>
<summary>JavaScript SDK</summary>

```ts
const aws = require("aws-sdk");

let tableName = "localstack-global";
const ddb = new aws.DynamoDB({
    region: "localstack",
    endpoint: "http://localhost:4566",
});

async function main() {
    await ddb.createTable({
        TableName: tableName,
        AttributeDefinitions: [{
            AttributeName: "partition_key",
            AttributeType: "S",
        }],
        KeySchema: [{
            AttributeName: "partition_key",
            KeyType: "HASH",
        }],
        BillingMode: "PAY_PER_REQUEST",
    }).promise();

    console.log("Table", tableName, "is created");

    const req = ddb.transactWriteItems({
        TransactItems: [
            {
                ConditionCheck: {
                    TableName: tableName,
                    ConditionExpression: "attribute_not_exists(partition_key)",
                    Key: {
                        partition_key: {
                            S: "foo",
                        },
                    },
                },
            },
            {
                Put: {
                    Item: {
                        partition_key: {
                            S: "bar",
                        },
                    },
                    TableName: tableName,
                },
            },
        ],
    });
    console.time("transact");
    await req.promise().then(
        result => console.log("Ok", result),
        err => console.error("Err", err),
    );
    console.timeEnd("transact");

    const result = await ddb.scan({ TableName: tableName });
    console.log("Items:",  (await result.promise()).Items);
}

main().then(() => console.log("Done"), err => console.error("Whoops:", err));
```
For some reason it takes a lot of time for it to error out, here is the output:
```bash
~/junk/ts-sandbox $ node index.js 
Table localstack-global-6 is created
Err Error [UnknownError]: null
    at Request.extractError (/home/veetaha/junk/ts-sandbox/node_modules/aws-sdk/lib/protocol/json.js:51:27)
    at Request.callListeners (/home/veetaha/junk/ts-sandbox/node_modules/aws-sdk/lib/sequential_executor.js:106:20)
    at Request.emit (/home/veetaha/junk/ts-sandbox/node_modules/aws-sdk/lib/sequential_executor.js:78:10)
    at Request.emit (/home/veetaha/junk/ts-sandbox/node_modules/aws-sdk/lib/request.js:688:14)
    at Request.transition (/home/veetaha/junk/ts-sandbox/node_modules/aws-sdk/lib/request.js:22:10)
    at AcceptorStateMachine.runTo (/home/veetaha/junk/ts-sandbox/node_modules/aws-sdk/lib/state_machine.js:14:12)
    at /home/veetaha/junk/ts-sandbox/node_modules/aws-sdk/lib/state_machine.js:26:10
    at Request.<anonymous> (/home/veetaha/junk/ts-sandbox/node_modules/aws-sdk/lib/request.js:38:9)
    at Request.<anonymous> (/home/veetaha/junk/ts-sandbox/node_modules/aws-sdk/lib/request.js:690:12)
    at Request.callListeners (/home/veetaha/junk/ts-sandbox/node_modules/aws-sdk/lib/sequential_executor.js:116:18) {
  code: 'UnknownError',
  time: 2020-07-18T14:41:19.788Z,
  requestId: undefined,
  statusCode: 500,
  retryable: true
}
transact: 40.678s
Items: [ { partition_key: { S: 'bar' } } ]
Done
```
</details>

Rust SDK gives more info about the failed request and also doesn't have that weird 40s latency (it is instant)

<details>
<summary>Rust SDK</summary>

```rust
#![allow(unused)]
use dynamodb::DynamoDb;
use dynomite::{dynamodb, attr_map};
use rusoto_core::RusotoResult;

#[tokio::main]
async fn main() {
    let table_name = "localstack-global".to_owned();
    let client = dynamodb::DynamoDbClient::new(rusoto_core::Region::Custom {
        name: "localstack".to_owned(),
        endpoint: "http://localhost:4566".to_owned()
    });
    client.create_table(dynamodb::CreateTableInput {
        attribute_definitions: vec![
            dynamodb::AttributeDefinition {
                attribute_name: "partition_key".to_owned(),
                attribute_type: "S".to_owned(),
            },
        ],
        key_schema: vec![
            dynamodb::KeySchemaElement {
                attribute_name: "partition_key".to_owned(),
                key_type: "HASH".to_owned(),
            },
        ],
        table_name: table_name.clone(),
        billing_mode: Some("PAY_PER_REQUEST".to_owned()),
        ..Default::default()
    }).await.unwrap();
    let result = client.transact_write_items(dynamodb::TransactWriteItemsInput {
        transact_items: vec![
            dynamodb::TransactWriteItem {
                condition_check: Some(dynamodb::ConditionCheck {
                    table_name: table_name.clone(),
                    condition_expression: "attribute_not_exists(partition_key)".to_owned(),
                    key: attr_map! {
                        "partition_key" => "foo".to_owned(),
                    },
                    ..Default::default()
                }),
                ..Default::default()
            },
            dynamodb::TransactWriteItem {
                put: Some(dynamodb::Put {
                    item: attr_map! {
                        "partition_key" => "bar".to_owned()
                    },
                    table_name: table_name.clone(),
                    ..Default::default()
                }),
                ..Default::default()
            },
        ],
        ..Default::default()
    }).await;

    dbg!(result);
}
```

Output:
```bash
~/junk/rust-sandbox $ cargo run
   Compiling crate_foo v0.1.0 (/home/veetaha/junk/rust-sandbox/crate_foo)
    Finished dev [unoptimized + debuginfo] target(s) in 4.20s
     Running `target/debug/crate_foo`
[crate_foo/src/main.rs:57] result = Err(
    Unknown(
        BufferedHttpResponse {status: 500, body: "{}", headers: {"content-type": "text/html; charset=utf-8", "content-length": "2", "access-control-allow-origin": "*", "access-control-allow-methods": "HEAD,GET,PUT,POST,DELETE,OPTIONS,PATCH", "access-control-allow-headers": "authorization,content-type,content-md5,cache-control,x-amz-content-sha256,x-amz-date,x-amz-security-token,x-amz-user-agent,x-amz-target,x-amz-acl,x-amz-version-id,x-localstack-target,x-amz-tagging", "access-control-expose-headers": "x-amz-version-id", "connection": "close", "date": "Sat, 18 Jul 2020 14:46:04 GMT", "server": "hypercorn-h11"} },
    ),
)
```
</details>
import unittest
import json
from datetime import datetime
from localstack.services.dynamodbstreams.dynamodbstreams_api import get_kinesis_stream_name
from localstack.utils import testutil
from localstack.utils.aws import aws_stack
from localstack.utils.aws.aws_models import KinesisStream
from localstack.utils.aws.aws_stack import get_environment
from localstack.utils.common import json_safe, short_uid
PARTITION_KEY = 'id'
TEST_DDB_TABLE_NAME = 'test-ddb-table-1'
TEST_DDB_TABLE_NAME_2 = 'test-ddb-table-2'
TEST_DDB_TABLE_NAME_3 = 'test-ddb-table-3'
TEST_DDB_TABLE_NAME_4 = 'test-ddb-table-4'
TEST_DDB_TAGS = [
    {
        'Key': 'Name',
        'Value': 'test-table'
    },
    {
        'Key': 'TestKey',
        'Value': 'true'
    }
]
class DynamoDBIntegrationTest (unittest.TestCase):