localstack-core 4.13.2.dev62__tar.gz → 4.13.2.dev64__tar.gz

{localstack_core-4.13.2.dev62 → localstack_core-4.13.2.dev64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localstack-core
-Version: 4.13.2.dev62
+Version: 4.13.2.dev64
 Summary: The core library and runtime of LocalStack
 Author-email: LocalStack Contributors <info@localstack.cloud>
 License-Expression: Apache-2.0

{localstack_core-4.13.2.dev62 → localstack_core-4.13.2.dev64}/localstack-core/localstack/services/apigateway/legacy/provider.py

@@ -1174,6 +1174,10 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
             self._patch_stage_response(stage)
             if not stage.get("description"):
                 stage.pop("description", None)
+        if deployment_id:
+            response["item"] = [
+                s for s in response["item"] if s.get("deploymentId") == deployment_id
+            ]
         return Stages(**response)
 
     @handler("UpdateStage")

{localstack_core-4.13.2.dev62 → localstack_core-4.13.2.dev64}/localstack-core/localstack/services/dynamodb/models.py

@@ -3,10 +3,15 @@ from typing import TypedDict
 
 from localstack.aws.api.dynamodb import (
     AttributeMap,
+    BackupDetails,
+    ContinuousBackupsDescription,
+    GlobalTableDescription,
     Key,
+    KinesisDataStreamDestination,
     RegionName,
     ReplicaDescription,
     StreamViewType,
+    TableDescription,
     TableName,
     TimeToLiveSpecification,
 )
@@ -91,9 +96,20 @@ class TableRecords(TypedDict):
 RecordsMap = dict[TableName, TableRecords]
 
 
+class TableProperties(TypedDict, total=False):
+    ContinuousBackupsDescription: ContinuousBackupsDescription
+
+
+@dataclasses.dataclass
+class Backup:
+    details: BackupDetails
+    backup_file: str
+    table_name: str
+
+
 class DynamoDBStore(BaseStore):
     # maps global table names to configurations (for the legacy v.2017 tables)
-    GLOBAL_TABLES: dict[str, dict] = CrossRegionAttribute(default=dict)
+    GLOBAL_TABLES: dict[str, GlobalTableDescription] = CrossRegionAttribute(default=dict)
 
     # Maps table name to the region they exist in on DDBLocal (for v.2019 global tables)
     TABLE_REGION: dict[TableName, RegionName] = CrossRegionAttribute(default=dict)
@@ -104,19 +120,24 @@ class DynamoDBStore(BaseStore):
     )
 
     # cache table taggings - maps table ARN to tags dict
-    TABLE_TAGS: dict[str, dict] = CrossRegionAttribute(default=dict)
+    TABLE_TAGS: dict[str, dict[str, str]] = CrossRegionAttribute(default=dict)
 
     # maps table names to cached table definitions
-    table_definitions: dict[str, dict] = LocalAttribute(default=dict)
+    table_definitions: dict[str, TableDescription] = LocalAttribute(default=dict)
+
+    # map table name to streaming destinations
+    streaming_destinations: dict[str, list[KinesisDataStreamDestination]] = LocalAttribute(
+        default=dict
+    )
 
     # maps table names to additional table properties that are not stored upstream (e.g., ReplicaUpdates)
-    table_properties: dict[str, dict] = LocalAttribute(default=dict)
+    table_properties: dict[str, TableProperties] = LocalAttribute(default=dict)
 
     # maps table names to TTL specifications
     ttl_specifications: dict[str, TimeToLiveSpecification] = LocalAttribute(default=dict)
 
     # maps backups
-    backups: dict[str, dict] = LocalAttribute(default=dict)
+    backups: dict[str, Backup] = LocalAttribute(default=dict)
 
 
 dynamodb_stores = AccountRegionBundle("dynamodb", DynamoDBStore)

{localstack_core-4.13.2.dev62 → localstack_core-4.13.2.dev64}/localstack-core/localstack/services/dynamodb/provider.py

@@ -6,7 +6,6 @@ import random
 import re
 import threading
 import time
-import traceback
 from collections import defaultdict
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import contextmanager
@@ -64,6 +63,7 @@ from localstack.aws.api.dynamodb import (
     GetItemOutput,
     GlobalTableAlreadyExistsException,
     GlobalTableNotFoundException,
+    KinesisDataStreamDestination,
     KinesisStreamingDestinationOutput,
     ListGlobalTablesOutput,
     ListTablesInputLimit,
@@ -274,7 +274,12 @@ class EventForwarder:
             table_arn = arns.dynamodb_table_arn(table_name, account_id, region_name)
             records = table_records["records"]
             table_def = store.table_definitions.get(table_name) or {}
-            stream_arn = table_def["KinesisDataStreamDestinations"][-1]["StreamArn"]
+            destinations = store.streaming_destinations.get(table_name)
+            if not destinations:
+                LOG.debug("Table %s has no Kinesis streaming destinations enabled", table_name)
+                continue
+
+            stream_arn = destinations[-1]["StreamArn"]
             for record in records:
                 kinesis_record = dict(
                     tableName=table_name,
@@ -1665,34 +1670,32 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
         if not stream:
             raise ValidationException("User does not have a permission to use kinesis stream")
 
-        table_def = get_store(context.account_id, context.region).table_definitions.setdefault(
-            table_name, {}
-        )
-
-        dest_status = table_def.get("KinesisDataStreamDestinationStatus")
-        if dest_status not in ["DISABLED", "ENABLE_FAILED", None]:
-            raise ValidationException(
-                "Table is not in a valid state to enable Kinesis Streaming "
-                "Destination:EnableKinesisStreamingDestination must be DISABLED or ENABLE_FAILED "
-                "to perform ENABLE operation."
-            )
+        store = get_store(context.account_id, context.region)
+        streaming_destinations = store.streaming_destinations.get(table_name) or []
 
-        table_def.setdefault("KinesisDataStreamDestinations", [])
+        destinations = [d for d in streaming_destinations if d["StreamArn"] == stream_arn]
+        if destinations:
+            status = destinations[0].get("DestinationStatus", None)
+            if status not in ["DISABLED", "ENABLED_FAILED", None]:
+                raise ValidationException(
+                    "Table is not in a valid state to enable Kinesis Streaming "
+                    "Destination:EnableKinesisStreamingDestination must be DISABLED or ENABLE_FAILED "
+                    "to perform ENABLE operation."
+                )
 
         # remove the stream destination if already present
-        table_def["KinesisDataStreamDestinations"] = [
-            t for t in table_def["KinesisDataStreamDestinations"] if t["StreamArn"] != stream_arn
+        store.streaming_destinations[table_name] = [
+            _d for _d in streaming_destinations if _d["StreamArn"] != stream_arn
         ]
         # append the active stream destination at the end of the list
-        table_def["KinesisDataStreamDestinations"].append(
-            {
-                "DestinationStatus": DestinationStatus.ACTIVE,
-                "DestinationStatusDescription": "Stream is active",
-                "StreamArn": stream_arn,
-                "ApproximateCreationDateTimePrecision": ApproximateCreationDateTimePrecision.MILLISECOND,
-            }
+        store.streaming_destinations[table_name].append(
+            KinesisDataStreamDestination(
+                DestinationStatus=DestinationStatus.ACTIVE,
+                DestinationStatusDescription="Stream is active",
+                StreamArn=stream_arn,
+                ApproximateCreationDateTimePrecision=ApproximateCreationDateTimePrecision.MILLISECOND,
+            )
         )
-        table_def["KinesisDataStreamDestinationStatus"] = DestinationStatus.ACTIVE
         return KinesisStreamingDestinationOutput(
             DestinationStatus=DestinationStatus.ENABLING,
             StreamArn=stream_arn,
@@ -1715,34 +1718,25 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
             error_message=f"Requested resource not found: Table: {table_name} not found",
         )
 
-        # TODO: Must raise if invoked before KinesisStreamingDestination is ACTIVE
-
         stream = self._event_forwarder.is_kinesis_stream_exists(stream_arn=stream_arn)
         if not stream:
             raise ValidationException(
                 "User does not have a permission to use kinesis stream",
             )
 
-        table_def = get_store(context.account_id, context.region).table_definitions.setdefault(
-            table_name, {}
-        )
-
-        stream_destinations = table_def.get("KinesisDataStreamDestinations")
-        if stream_destinations:
-            if table_def["KinesisDataStreamDestinationStatus"] == DestinationStatus.ACTIVE:
-                for dest in stream_destinations:
-                    if (
-                        dest["StreamArn"] == stream_arn
-                        and dest["DestinationStatus"] == DestinationStatus.ACTIVE
-                    ):
-                        dest["DestinationStatus"] = DestinationStatus.DISABLED
-                        dest["DestinationStatusDescription"] = ("Stream is disabled",)
-                        table_def["KinesisDataStreamDestinationStatus"] = DestinationStatus.DISABLED
-                        return KinesisStreamingDestinationOutput(
-                            DestinationStatus=DestinationStatus.DISABLING,
-                            StreamArn=stream_arn,
-                            TableName=table_name,
-                        )
+        store = get_store(context.account_id, context.region)
+        streaming_destinations = store.streaming_destinations.get(table_name) or []
+
+        # Get the right destination based on the arn
+        destinations = [d for d in streaming_destinations if d["StreamArn"] == stream_arn]
+        if destinations:
+            destinations[0]["DestinationStatus"] = DestinationStatus.DISABLED
+            destinations[0]["DestinationStatusDescription"] = "Stream is disabled"
+            return KinesisStreamingDestinationOutput(
+                DestinationStatus=DestinationStatus.DISABLING,
+                StreamArn=stream_arn,
+                TableName=table_name,
+            )
         raise ValidationException(
             "Table is not in a valid state to disable Kinesis Streaming Destination:"
             "DisableKinesisStreamingDestination must be ACTIVE to perform DISABLE operation."
@@ -1753,12 +1747,9 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
     ) -> DescribeKinesisStreamingDestinationOutput:
         self.ensure_table_exists(context.account_id, context.region, table_name)
 
-        table_def = (
-            get_store(context.account_id, context.region).table_definitions.get(table_name) or {}
-        )
-
-        stream_destinations = table_def.get("KinesisDataStreamDestinations") or []
-        stream_destinations = copy.deepcopy(stream_destinations)
+        store = get_store(context.account_id, context.region)
+        table_destinations = store.streaming_destinations.get(table_name) or []
+        stream_destinations = copy.deepcopy(table_destinations)
 
         for destination in stream_destinations:
             destination.pop("ApproximateCreationDateTimePrecision", None)
@@ -1799,23 +1790,21 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
             )
 
         store = get_store(context.account_id, context.region)
+        table_destinations = store.streaming_destinations.get(table_name) or []
 
-        table_def = store.table_definitions.get(table_name) or {}
-        table_def.setdefault("KinesisDataStreamDestinations", [])
-
-        table_id = table_def["TableId"]
-
-        destination = None
-        for stream in table_def["KinesisDataStreamDestinations"]:
-            if stream["StreamArn"] == stream_arn:
-                destination = stream
-
-        if destination is None:
+        # filter the right destination based on the stream ARN
+        destinations = [d for d in table_destinations if d["StreamArn"] == stream_arn]
+        if not destinations:
             raise ValidationException(
                 "Table is not in a valid state to enable Kinesis Streaming Destination: "
                 f"No streaming destination with streamArn: {stream_arn} found for table with tableName: {table_name}"
             )
 
+        destination = destinations[0]
+        table_def = store.table_definitions.get(table_name) or {}
+        table_def.setdefault("KinesisDataStreamDestinations", [])
+
+        table_id = store.table_definitions.get(table_name, {}).get("TableId")
         if (
             existing_precision := destination["ApproximateCreationDateTimePrecision"]
         ) == update_kinesis_streaming_configuration["ApproximateCreationDateTimePrecision"]:
@@ -1823,7 +1812,6 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
                 f"Invalid Request: Precision is already set to the desired value of {existing_precision} "
                 f"for tableId: {table_id}, kdsArn: {stream_arn}"
             )
-
         destination["ApproximateCreationDateTimePrecision"] = time_precision
 
         return UpdateKinesisStreamingDestinationOutput(
@@ -2317,19 +2305,20 @@ def get_table_stream_type(
     :return: a TableStreamViewType object if the table has streams enabled. If not, return None
     """
     if not table_name_or_arn:
-        return
+        return None
 
     table_name = table_name_or_arn.split(":table/")[-1]
 
     is_kinesis = False
     stream_view_type = None
 
-    if table_definition := get_store(account_id, region_name).table_definitions.get(table_name):
-        if table_definition.get("KinesisDataStreamDestinationStatus") == "ACTIVE":
+    # To determine if stream to kinesis is enabled, we look for active kinesis destinations
+    destinations = get_store(account_id, region_name).streaming_destinations.get(table_name) or []
+    for destination in destinations:
+        if destination["DestinationStatus"] == DestinationStatus.ACTIVE:
             is_kinesis = True
 
     table_arn = arns.dynamodb_table_arn(table_name, account_id=account_id, region_name=region_name)
-
     if (
         stream := dynamodbstreams_api.get_stream_for_table(account_id, region_name, table_arn)
     ) and stream["StreamStatus"] in (StreamStatus.ENABLING, StreamStatus.ENABLED):
@@ -2337,6 +2326,7 @@ def get_table_stream_type(
 
     if is_kinesis or stream_view_type:
         return TableStreamType(stream_view_type, is_kinesis=is_kinesis)
+    return None
 
 
 def get_updated_records(
@@ -2410,7 +2400,9 @@ def get_updated_records(
     return {table_name: TableRecords(records=result, table_stream_type=table_stream_type)}
 
 
-def create_dynamodb_stream(account_id: str, region_name: str, data, latest_stream_label):
+def create_dynamodb_stream(
+    account_id: str, region_name: str, data: CreateTableInput, latest_stream_label: str | None
+) -> None:
     stream = data["StreamSpecification"]
     enabled = stream.get("StreamEnabled")
 
@@ -2428,22 +2420,6 @@ def create_dynamodb_stream(account_id: str, region_name: str, data, latest_strea
         )
 
 
-def dynamodb_get_table_stream_specification(account_id: str, region_name: str, table_name: str):
-    try:
-        table_schema = SchemaExtractor.get_table_schema(
-            table_name, account_id=account_id, region_name=region_name
-        )
-        return table_schema["Table"].get("StreamSpecification")
-    except Exception as e:
-        LOG.info(
-            "Unable to get stream specification for table %s: %s %s",
-            table_name,
-            e,
-            traceback.format_exc(),
-        )
-        raise e
-
-
 def find_item_for_keys_values_in_batch(
     table_name: str, item_keys: dict, batch: BatchGetResponseMap
 ) -> AttributeMap | None:

{localstack_core-4.13.2.dev62 → localstack_core-4.13.2.dev64}/localstack-core/localstack/services/dynamodb/v2/provider.py

@@ -58,6 +58,7 @@ from localstack.aws.api.dynamodb import (
     GetItemOutput,
     GlobalTableAlreadyExistsException,
     GlobalTableNotFoundException,
+    KinesisDataStreamDestination,
     KinesisStreamingDestinationOutput,
     ListGlobalTablesOutput,
     ListTablesInputLimit,
@@ -1196,34 +1197,32 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
         if not kinesis_stream_exists(stream_arn=stream_arn):
             raise ValidationException("User does not have a permission to use kinesis stream")
 
-        table_def = get_store(context.account_id, context.region).table_definitions.setdefault(
-            table_name, {}
-        )
-
-        dest_status = table_def.get("KinesisDataStreamDestinationStatus")
-        if dest_status not in ["DISABLED", "ENABLE_FAILED", None]:
-            raise ValidationException(
-                "Table is not in a valid state to enable Kinesis Streaming "
-                "Destination:EnableKinesisStreamingDestination must be DISABLED or ENABLE_FAILED "
-                "to perform ENABLE operation."
-            )
+        store = get_store(context.account_id, context.region)
+        streaming_destinations = store.streaming_destinations.get(table_name) or []
 
-        table_def.setdefault("KinesisDataStreamDestinations", [])
+        destinations = [d for d in streaming_destinations if d["StreamArn"] == stream_arn]
+        if destinations:
+            status = destinations[0].get("DestinationStatus", None)
+            if status not in ["DISABLED", "ENABLED_FAILED", None]:
+                raise ValidationException(
+                    "Table is not in a valid state to enable Kinesis Streaming "
+                    "Destination:EnableKinesisStreamingDestination must be DISABLED or ENABLE_FAILED "
+                    "to perform ENABLE operation."
+                )
 
         # remove the stream destination if already present
-        table_def["KinesisDataStreamDestinations"] = [
-            t for t in table_def["KinesisDataStreamDestinations"] if t["StreamArn"] != stream_arn
+        store.streaming_destinations[table_name] = [
+            _d for _d in streaming_destinations if _d["StreamArn"] != stream_arn
         ]
         # append the active stream destination at the end of the list
-        table_def["KinesisDataStreamDestinations"].append(
-            {
-                "DestinationStatus": DestinationStatus.ACTIVE,
-                "DestinationStatusDescription": "Stream is active",
-                "StreamArn": stream_arn,
-                "ApproximateCreationDateTimePrecision": ApproximateCreationDateTimePrecision.MILLISECOND,
-            }
+        store.streaming_destinations[table_name].append(
+            KinesisDataStreamDestination(
+                DestinationStatus=DestinationStatus.ACTIVE,
+                DestinationStatusDescription="Stream is active",
+                StreamArn=stream_arn,
+                ApproximateCreationDateTimePrecision=ApproximateCreationDateTimePrecision.MILLISECOND,
+            )
         )
-        table_def["KinesisDataStreamDestinationStatus"] = DestinationStatus.ACTIVE
         return KinesisStreamingDestinationOutput(
             DestinationStatus=DestinationStatus.ENABLING,
             StreamArn=stream_arn,
@@ -1251,26 +1250,19 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
                 "User does not have a permission to use kinesis stream",
             )
 
-        table_def = get_store(context.account_id, context.region).table_definitions.setdefault(
-            table_name, {}
-        )
-
-        stream_destinations = table_def.get("KinesisDataStreamDestinations")
-        if stream_destinations:
-            if table_def["KinesisDataStreamDestinationStatus"] == DestinationStatus.ACTIVE:
-                for dest in stream_destinations:
-                    if (
-                        dest["StreamArn"] == stream_arn
-                        and dest["DestinationStatus"] == DestinationStatus.ACTIVE
-                    ):
-                        dest["DestinationStatus"] = DestinationStatus.DISABLED
-                        dest["DestinationStatusDescription"] = ("Stream is disabled",)
-                        table_def["KinesisDataStreamDestinationStatus"] = DestinationStatus.DISABLED
-                        return KinesisStreamingDestinationOutput(
-                            DestinationStatus=DestinationStatus.DISABLING,
-                            StreamArn=stream_arn,
-                            TableName=table_name,
-                        )
+        store = get_store(context.account_id, context.region)
+        streaming_destinations = store.streaming_destinations.get(table_name) or []
+
+        # Get the right destination based on the arn
+        destinations = [d for d in streaming_destinations if d["StreamArn"] == stream_arn]
+        if destinations:
+            destinations[0]["DestinationStatus"] = DestinationStatus.DISABLED
+            destinations[0]["DestinationStatusDescription"] = "Stream is disabled"
+            return KinesisStreamingDestinationOutput(
+                DestinationStatus=DestinationStatus.DISABLING,
+                StreamArn=stream_arn,
+                TableName=table_name,
+            )
         raise ValidationException(
             "Table is not in a valid state to disable Kinesis Streaming Destination:"
             "DisableKinesisStreamingDestination must be ACTIVE to perform DISABLE operation."
@@ -1281,12 +1273,9 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
     ) -> DescribeKinesisStreamingDestinationOutput:
         self.ensure_table_exists(context.account_id, context.region, table_name)
 
-        table_def = (
-            get_store(context.account_id, context.region).table_definitions.get(table_name) or {}
-        )
-
-        stream_destinations = table_def.get("KinesisDataStreamDestinations") or []
-        stream_destinations = copy.deepcopy(stream_destinations)
+        store = get_store(context.account_id, context.region)
+        table_destinations = store.streaming_destinations.get(table_name) or []
+        stream_destinations = copy.deepcopy(table_destinations)
 
         for destination in stream_destinations:
             destination.pop("ApproximateCreationDateTimePrecision", None)
@@ -1327,23 +1316,21 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
             )
 
         store = get_store(context.account_id, context.region)
+        table_destinations = store.streaming_destinations.get(table_name) or []
 
-        table_def = store.table_definitions.get(table_name) or {}
-        table_def.setdefault("KinesisDataStreamDestinations", [])
-
-        table_id = table_def["TableId"]
-
-        destination = None
-        for stream in table_def["KinesisDataStreamDestinations"]:
-            if stream["StreamArn"] == stream_arn:
-                destination = stream
-
-        if destination is None:
+        # filter the right destination based on the stream ARN
+        destinations = [d for d in table_destinations if d["StreamArn"] == stream_arn]
+        if not destinations:
             raise ValidationException(
                 "Table is not in a valid state to enable Kinesis Streaming Destination: "
                 f"No streaming destination with streamArn: {stream_arn} found for table with tableName: {table_name}"
             )
 
+        destination = destinations[0]
+        table_def = store.table_definitions.get(table_name) or {}
+        table_def.setdefault("KinesisDataStreamDestinations", [])
+
+        table_id = store.table_definitions.get(table_name, {}).get("TableId")
         if (
             existing_precision := destination["ApproximateCreationDateTimePrecision"]
         ) == update_kinesis_streaming_configuration["ApproximateCreationDateTimePrecision"]:
@@ -1351,7 +1338,6 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
                 f"Invalid Request: Precision is already set to the desired value of {existing_precision} "
                 f"for tableId: {table_id}, kdsArn: {stream_arn}"
             )
-
         destination["ApproximateCreationDateTimePrecision"] = time_precision
 
         return UpdateKinesisStreamingDestinationOutput(
@@ -1625,7 +1611,7 @@ def is_index_query_valid(account_id: str, region_name: str, query_data: dict) ->
     return True
 
 
-def kinesis_stream_exists(stream_arn):
+def kinesis_stream_exists(stream_arn: str) -> bool:
     account_id = extract_account_id_from_arn(stream_arn)
     region_name = extract_region_from_arn(stream_arn)
 

{localstack_core-4.13.2.dev62 → localstack_core-4.13.2.dev64}/localstack-core/localstack/services/dynamodbstreams/dynamodbstreams_api.py

@@ -6,10 +6,19 @@ from bson.json_util import dumps
 
 from localstack import config
 from localstack.aws.api import RequestContext
-from localstack.aws.api.dynamodbstreams import StreamStatus, StreamViewType, TableName
+from localstack.aws.api.dynamodbstreams import (
+    StreamDescription,
+    StreamStatus,
+    StreamViewType,
+    TableName,
+)
 from localstack.aws.connect import connect_to
 from localstack.services.dynamodb.v2.provider import DynamoDBProvider
-from localstack.services.dynamodbstreams.models import DynamoDbStreamsStore, dynamodbstreams_stores
+from localstack.services.dynamodbstreams.models import (
+    DynamoDbStreamsStore,
+    StreamWrapper,
+    dynamodbstreams_stores,
+)
 from localstack.utils.aws import arns, resources
 from localstack.utils.common import now_utc
 from localstack.utils.threads import FuncThread
@@ -65,28 +74,32 @@ def add_dynamodb_stream(
         stream_name=stream_name,
     )
     latest_stream_label = latest_stream_label or "latest"
-    stream = {
-        "StreamArn": arns.dynamodb_stream_arn(
-            table_name=table_name,
-            latest_stream_label=latest_stream_label,
-            account_id=account_id,
-            region_name=region_name,
-        ),
-        "TableName": table_name,
-        "StreamLabel": latest_stream_label,
-        "StreamStatus": StreamStatus.ENABLING,
-        "KeySchema": [],
-        "Shards": [],
-        "StreamViewType": view_type,
-        "shards_id_map": {},
-    }
-    store.ddb_streams[table_name] = stream
-
-
-def get_stream_for_table(account_id: str, region_name: str, table_arn: str) -> dict:
+    stream_arn = arns.dynamodb_stream_arn(
+        table_name=table_name,
+        latest_stream_label=latest_stream_label,
+        account_id=account_id,
+        region_name=region_name,
+    )
+    stream = StreamDescription(
+        TableName=table_name,
+        StreamArn=stream_arn,
+        StreamLabel=latest_stream_label,
+        StreamStatus=StreamStatus.ENABLING,
+        KeySchema=[],
+        Shards=[],
+        StreamViewType=view_type,
+    )
+    store.ddb_streams[table_name] = StreamWrapper(StreamDescription=stream)
+
+
+def get_stream_for_table(
+    account_id: str, region_name: str, table_arn: str
+) -> StreamDescription | None:
     store = get_dynamodbstreams_store(account_id, region_name)
     table_name = table_name_from_stream_arn(table_arn)
-    return store.ddb_streams.get(table_name)
+    if stream := store.ddb_streams.get(table_name):
+        return stream.StreamDescription
+    return None
 
 
 def _process_forwarded_records(
@@ -206,11 +219,11 @@ def kinesis_shard_id(dynamodbstream_shard_id: str) -> str:
     return f"{shard_params[0]}-{shard_params[-1]}"
 
 
-def get_shard_id(stream: dict, kinesis_shard_id: str) -> str:
-    ddb_stream_shard_id = stream.get("shards_id_map", {}).get(kinesis_shard_id)
+def get_shard_id(stream: StreamWrapper, kinesis_shard_id: str) -> str:
+    ddb_stream_shard_id = stream.shards_id_map.get(kinesis_shard_id)
     if not ddb_stream_shard_id:
         ddb_stream_shard_id = shard_id(kinesis_shard_id)
-        stream["shards_id_map"][kinesis_shard_id] = ddb_stream_shard_id
+        stream.shards_id_map[kinesis_shard_id] = ddb_stream_shard_id
 
     return ddb_stream_shard_id
 

localstack_core-4.13.2.dev64/localstack-core/localstack/services/dynamodbstreams/models.py

@@ -0,0 +1,19 @@
+import dataclasses
+
+from localstack.aws.api.dynamodbstreams import StreamDescription
+from localstack.services.stores import AccountRegionBundle, BaseStore, LocalAttribute
+
+
+@dataclasses.dataclass
+class StreamWrapper:
+    """Wrapper for the API stub and additional information about a store"""
+
+    StreamDescription: StreamDescription
+    shards_id_map: dict[str, str] = dataclasses.field(default_factory=dict)
+
+
+class DynamoDbStreamsStore(BaseStore):
+    ddb_streams: dict[str, StreamWrapper] = LocalAttribute(default=dict)
+
+
+dynamodbstreams_stores = AccountRegionBundle("dynamodbstreams", DynamoDbStreamsStore)