port-ocean 0.30.4__py3-none-any.whl → 0.30.5__py3-none-any.whl

port_ocean/core/integrations/mixins/utils.py

@@ -9,6 +9,7 @@ import subprocess
 import tempfile
 from contextlib import contextmanager
 from typing import Any, AsyncGenerator, Awaitable, Callable, Generator, cast
+import copy
 
 import ijson
 from loguru import logger
@@ -124,8 +125,8 @@ async def resync_generator_wrapper(
                         if items_to_parse:
                             for data in result:
                                 data_path: str | None = None
-                                if isinstance(data, dict) and data.get("file") is not None:
-                                    content = data["file"].get("content") if isinstance(data["file"].get("content"), dict) else {}
+                                if isinstance(data, dict) and data.get("__type") == "path":
+                                    content = data.get("file", {}).get("content") if isinstance(data["file"].get("content"), dict) else {}
                                     data_path = content.get("path", None)
                                 bulks = get_items_to_parse_bulks(data, data_path, items_to_parse, items_to_parse_name, data.get("__base_jq", ".file.content"))
                                 async for bulk in bulks:
@@ -147,6 +148,62 @@ async def resync_generator_wrapper(
                 "At least one of the resync generator iterations failed", errors
             )
 
+def extract_jq_deletion_path_revised(jq_expression: str) -> str | None:
+    """
+    Revised function to extract a simple path suitable for del() by analyzing pipe segments.
+    """
+    expr = jq_expression.strip()
+
+    # 1. Handle surrounding parentheses and extract the main chain
+    if expr.startswith('('):
+        match_paren = re.match(r'\((.*?)\)', expr, re.DOTALL)
+        if match_paren:
+            chain = match_paren.group(1).strip()
+        else:
+            return None
+    else:
+        chain = expr
+
+    # 2. Split the chain by the main pipe operator (excluding pipes inside quotes or brackets,
+    # but for simplicity here, we split naively and check segments)
+    segments = chain.split('|')
+
+    # 3. Analyze each segment for a simple path
+    for segment in segments:
+        segment = segment.strip()
+
+        # Ignore variable assignment segments like '. as $root'
+        if re.match(r'^\.\s+as\s+\$\w+', segment):
+            continue
+
+        # Ignore identity and variable access like '.' or '$items'
+        if segment == '.' or segment.startswith('$'):
+            continue
+
+        # Look for the first genuine path accessor (e.g., .key, .[index], .key.nested, .key[0])
+        # This regex looks for a starting dot and follows it with path components
+        # (alphanumeric keys or bracketed accessors, where brackets can follow words directly)
+        # Pattern: Start with .word or .[index], then optionally more:
+        #   - .word (dot followed by word)
+        #   - [index] (bracket directly after word, no dot)
+        #   - .[index] (dot followed by bracket)
+        path_match = re.match(r'(\.[\w]+|\.\[[^\]]+\])(\.[\w]+|\[[^\]]+\]|\.\[[^\]]+\])*', segment)
+
+        if path_match:
+            path = path_match.group(0).strip()
+
+            # If the path is immediately followed by a simple fallback (// value),
+            # we consider the path complete.
+            if re.search(r'\s*//\s*(\[\]|null|\.|\{.*?\})', segment):
+                return path
+
+            # If the path is just a path segment followed by nothing or the end of a complex
+            # expression (like .file.content.raw) we return it.
+            return path
+
+    # Default case: No suitable path found after checking all segments
+    return None
+
 
 def is_resource_supported(
     kind: str, resync_event_mapping: dict[str | None, list[RESYNC_EVENT_LISTENER]]
@@ -197,6 +254,7 @@ async def get_items_to_parse_bulks(raw_data: dict[Any, Any], data_path: str, ite
     temp_output_path = None
 
     try:
+        is_path_type = True
         # Create secure temporary files
         if not data_path:
             raw_data_serialized = json.dumps(raw_data)
@@ -204,17 +262,17 @@ async def get_items_to_parse_bulks(raw_data: dict[Any, Any], data_path: str, ite
             with open(temp_data_path, "w") as f:
                 f.write(raw_data_serialized)
             data_path = temp_data_path
+            is_path_type = False
 
         temp_output_path = _create_secure_temp_file("_parsed.json")
 
-        delete_target = items_to_parse.split('|', 1)[0].strip() if not items_to_parse.startswith('map(') else '.'
-        base_jq_object_string = await _build_base_jq_object_string(raw_data, base_jq, delete_target)
+        delete_target = extract_jq_deletion_path_revised(items_to_parse) or '.'
 
         # Build jq expression safely
         jq_expression = f""". as $all
       | ($all | {items_to_parse}) as $items
       | $items
-      | map({{{items_to_parse_name}: ., {base_jq_object_string}}})"""
+      | {_build_mapping_jq_expression(items_to_parse_name, base_jq, delete_target, is_path_type)}"""
 
         # Use subprocess with list arguments instead of shell=True
 
@@ -237,7 +295,7 @@ async def get_items_to_parse_bulks(raw_data: dict[Any, Any], data_path: str, ite
             with open(temp_output_path, "r") as f:
                 events_stream = get_events_as_a_stream(f, 'item', ocean.config.yield_items_to_parse_batch_size)
                 for items_bulk in events_stream:
-                    yield items_bulk
+                    yield items_bulk if not is_path_type else [merge_raw_data_to_item(item, raw_data) for item in items_bulk]
 
     except ValueError as e:
         logger.error(f"Invalid jq expression: {e}")
@@ -260,13 +318,57 @@ def unsupported_kind_response(
     logger.error(f"Kind {kind} is not supported in this integration")
     return [], [KindNotImplementedException(kind, available_resync_kinds)]
 
-async def _build_base_jq_object_string(raw_data: dict[Any, Any], base_jq: str, delete_target: str) -> str:
-    base_jq_object_before_parsing = await cast(JQEntityProcessor, ocean.app.integration.entity_processor)._search(raw_data, f"{base_jq} = {json.dumps("__all")}")
-    base_jq_object_before_parsing_serialized = json.dumps(base_jq_object_before_parsing)
-    base_jq_object_before_parsing_serialized = base_jq_object_before_parsing_serialized[1:-1] if len(base_jq_object_before_parsing_serialized) >= 2 else base_jq_object_before_parsing_serialized
-    base_jq_object_before_parsing_serialized = base_jq_object_before_parsing_serialized.replace("\"__all\"", f"(($all | del({delete_target})) // {{}})")
-    return base_jq_object_before_parsing_serialized
+def _build_mapping_jq_expression(items_to_parse_name: str, base_jq: str, delete_target: str, is_path_type: bool = False) -> str:
+    if is_path_type:
+        return f"map({{{items_to_parse_name}: . }} | {base_jq} = (($all | del({delete_target})) // {{}}))"
+    return f"map(($all | del({delete_target})) + {{{items_to_parse_name}: . }})"
+
+def merge_raw_data_to_item(item: dict[str, Any], raw_data: dict[str, Any]) -> dict[str, Any]:
+    return recursive_dict_merge(raw_data, item)
+
+def recursive_dict_merge(d1: dict[Any, Any], d2: dict[Any, Any]) -> dict[Any, Any]:
+    """
+    Recursively merges dict d2 into dict d1.
+
+    If a key exists in both dictionaries:
+    1. If the value in d2 is an empty dictionary (e.g., {}), it overwrites the value in d1.
+    2. If both values are non-empty dictionaries, they are merged recursively.
+    3. Otherwise, the value from d2 overwrites the value from d1.
+
+    The original dictionaries are not modified (d1 is copied).
+
+    Args:
+        d1: The base dictionary (will be copied and modified).
+        d2: The dictionary to merge into d1.
+
+    Returns:
+        The merged dictionary.
+    """
+    # Start with a copy of d1 to ensure d1 is not mutated
+    merged_dict = copy.deepcopy(d1)
+
+    for key, value in d2.items():
+        # Condition to trigger recursive deep merge:
+        # 1. Key exists in merged_dict
+        # 2. Both values are dictionaries
+        # 3. The value from d2 is NOT an empty dictionary ({}).
+        #    If d2's value is {}, we treat it as an explicit instruction to overwrite/clear.
+        is_deep_merge = (
+            key in merged_dict and
+            isinstance(merged_dict[key], dict) and
+            isinstance(value, dict) and
+            value != {}
+        )
+
+        if is_deep_merge:
+            # If both are dictionaries and d2 is not empty, recurse
+            merged_dict[key] = recursive_dict_merge(merged_dict[key], value)
+        else:
+            # Otherwise (new key, non-dict value, or explicit {} overwrite),
+            # overwrite the value from d1 with the value from d2
+            merged_dict[key] = value
 
+    return merged_dict
 
 def get_events_as_a_stream(
         stream: Any,

port_ocean/tests/core/integrations/mixins/test_integration_utils.py

@@ -0,0 +1,494 @@
+import pytest
+
+from port_ocean.core.integrations.mixins.utils import (
+    _build_mapping_jq_expression,
+    extract_jq_deletion_path_revised,
+    recursive_dict_merge,
+)
+
+
+class TestBuildMappingJqExpression:
+    """Tests for _build_mapping_jq_expression function."""
+
+    def test_build_mapping_jq_expression_non_path_type(self) -> None:
+        """Test jq expression building for non-path type."""
+        items_to_parse_name = "items"
+        base_jq = ".file.content"
+        delete_target = ".file.content.raw"
+
+        result = _build_mapping_jq_expression(
+            items_to_parse_name, base_jq, delete_target, is_path_type=False
+        )
+
+        expected = "map(($all | del(.file.content.raw)) + {items: . })"
+        assert result == expected
+
+    def test_build_mapping_jq_expression_path_type(self) -> None:
+        """Test jq expression building for path type."""
+        items_to_parse_name = "items"
+        base_jq = ".file.content"
+        delete_target = ".file.content.raw"
+
+        result = _build_mapping_jq_expression(
+            items_to_parse_name, base_jq, delete_target, is_path_type=True
+        )
+
+        expected = "map({items: . } | .file.content = (($all | del(.file.content.raw)) // {}))"
+        assert result == expected
+
+    def test_build_mapping_jq_expression_with_different_delete_target(self) -> None:
+        """Test jq expression building with different delete targets."""
+        items_to_parse_name = "parsed_data"
+        base_jq = ".data"
+        delete_target = ".data.temp"
+
+        # Non-path type
+        result_non_path = _build_mapping_jq_expression(
+            items_to_parse_name, base_jq, delete_target, is_path_type=False
+        )
+        expected_non_path = "map(($all | del(.data.temp)) + {parsed_data: . })"
+        assert result_non_path == expected_non_path
+
+        # Path type
+        result_path = _build_mapping_jq_expression(
+            items_to_parse_name, base_jq, delete_target, is_path_type=True
+        )
+        expected_path = "map({parsed_data: . } | .data = (($all | del(.data.temp)) // {}))"
+        assert result_path == expected_path
+
+    def test_build_mapping_jq_expression_with_simple_delete_target(self) -> None:
+        """Test jq expression building with simple delete target."""
+        items_to_parse_name = "items"
+        base_jq = "."
+        delete_target = "."
+
+        # Non-path type
+        result_non_path = _build_mapping_jq_expression(
+            items_to_parse_name, base_jq, delete_target, is_path_type=False
+        )
+        expected_non_path = "map(($all | del(.)) + {items: . })"
+        assert result_non_path == expected_non_path
+
+        # Path type
+        result_path = _build_mapping_jq_expression(
+            items_to_parse_name, base_jq, delete_target, is_path_type=True
+        )
+        expected_path = "map({items: . } | . = (($all | del(.)) // {}))"
+        assert result_path == expected_path
+
+
+class TestRecursiveDictMerge:
+    """Tests for recursive_dict_merge function."""
+
+    def test_simple_merge_new_keys(self) -> None:
+        """Test merging dictionaries with new keys."""
+        d1 = {"a": 1, "b": 2}
+        d2 = {"c": 3, "d": 4}
+
+        result = recursive_dict_merge(d1, d2)
+
+        assert result == {"a": 1, "b": 2, "c": 3, "d": 4}
+        # Ensure original dicts are not modified
+        assert d1 == {"a": 1, "b": 2}
+        assert d2 == {"c": 3, "d": 4}
+
+    def test_simple_overwrite(self) -> None:
+        """Test overwriting values with non-dict values."""
+        d1 = {"a": 1, "b": 2}
+        d2 = {"b": 3, "c": 4}
+
+        result = recursive_dict_merge(d1, d2)
+
+        assert result == {"a": 1, "b": 3, "c": 4}
+
+    def test_deep_merge(self) -> None:
+        """Test recursive merging of nested dictionaries."""
+        d1 = {"a": 1, "nested": {"x": 10, "y": 20}}
+        d2 = {"b": 2, "nested": {"y": 30, "z": 40}}
+
+        result = recursive_dict_merge(d1, d2)
+
+        assert result == {"a": 1, "b": 2, "nested": {"x": 10, "y": 30, "z": 40}}
+
+    def test_empty_dict_overwrite(self) -> None:
+        """Test that empty dict in d2 overwrites non-empty dict in d1."""
+        d1 = {"a": 1, "nested": {"x": 10, "y": 20}}
+        d2 = {"nested": {}}
+
+        result = recursive_dict_merge(d1, d2)
+
+        assert result == {"a": 1, "nested": {}}
+
+    def test_empty_dict_overwrite_multiple_levels(self) -> None:
+        """Test empty dict overwrite at multiple nesting levels."""
+        d1 = {
+            "level1": {
+                "level2": {
+                    "level3": {"value": 100}
+                }
+            }
+        }
+        d2 = {
+            "level1": {
+                "level2": {}
+            }
+        }
+
+        result = recursive_dict_merge(d1, d2)
+
+        assert result == {"level1": {"level2": {}}}
+
+    def test_mixed_types(self) -> None:
+        """Test merging with mixed value types."""
+        d1 = {
+            "string": "hello",
+            "number": 42,
+            "list": [1, 2, 3],
+            "nested": {"a": 1}
+        }
+        d2 = {
+            "string": "world",
+            "number": 100,
+            "list": [4, 5, 6],
+            "nested": {"b": 2}
+        }
+
+        result = recursive_dict_merge(d1, d2)
+
+        assert result == {
+            "string": "world",
+            "number": 100,
+            "list": [4, 5, 6],
+            "nested": {"a": 1, "b": 2}
+        }
+
+    def test_deep_nested_merge(self) -> None:
+        """Test merging deeply nested structures."""
+        d1 = {
+            "a": {
+                "b": {
+                    "c": {
+                        "d": 1,
+                        "e": 2
+                    }
+                }
+            }
+        }
+        d2 = {
+            "a": {
+                "b": {
+                    "c": {
+                        "e": 3,
+                        "f": 4
+                    }
+                }
+            }
+        }
+
+        result = recursive_dict_merge(d1, d2)
+
+        assert result == {
+            "a": {
+                "b": {
+                    "c": {
+                        "d": 1,
+                        "e": 3,
+                        "f": 4
+                    }
+                }
+            }
+        }
+
+    def test_empty_dictionaries(self) -> None:
+        """Test merging with empty dictionaries."""
+        d1 = {}
+        d2 = {"a": 1}
+
+        result = recursive_dict_merge(d1, d2)
+
+        assert result == {"a": 1}
+
+    def test_both_empty_dictionaries(self) -> None:
+        """Test merging two empty dictionaries."""
+        d1 = {}
+        d2 = {}
+
+        result = recursive_dict_merge(d1, d2)
+
+        assert result == {}
+
+    def test_immutability_d1(self) -> None:
+        """Test that d1 is not modified by the merge operation."""
+        d1 = {"a": 1, "nested": {"x": 10}}
+        d2 = {"b": 2, "nested": {"y": 20}}
+
+        original_d1 = {"a": 1, "nested": {"x": 10}}
+        result = recursive_dict_merge(d1, d2)
+
+        # Verify d1 is unchanged
+        assert d1 == original_d1
+        # Verify result is correct
+        assert result == {"a": 1, "b": 2, "nested": {"x": 10, "y": 20}}
+
+    def test_immutability_d2(self) -> None:
+        """Test that d2 is not modified by the merge operation."""
+        d1 = {"a": 1}
+        d2 = {"b": 2, "nested": {"x": 10}}
+
+        original_d2 = {"b": 2, "nested": {"x": 10}}
+        result = recursive_dict_merge(d1, d2)
+
+        # Verify d2 is unchanged
+        assert d2 == original_d2
+        # Verify result is correct
+        assert result == {"a": 1, "b": 2, "nested": {"x": 10}}
+
+    def test_non_dict_value_overwrites_dict(self) -> None:
+        """Test that non-dict value in d2 overwrites dict value in d1."""
+        d1 = {"key": {"nested": "value"}}
+        d2 = {"key": "simple_string"}
+
+        result = recursive_dict_merge(d1, d2)
+
+        assert result == {"key": "simple_string"}
+
+    def test_dict_overwrites_non_dict_value(self) -> None:
+        """Test that dict value in d2 overwrites non-dict value in d1."""
+        d1 = {"key": "simple_string"}
+        d2 = {"key": {"nested": "value"}}
+
+        result = recursive_dict_merge(d1, d2)
+
+        assert result == {"key": {"nested": "value"}}
+
+    def test_complex_real_world_scenario(self) -> None:
+        """Test a complex real-world merge scenario."""
+        d1 = {
+            "metadata": {
+                "version": "1.0",
+                "author": "Alice",
+                "tags": ["python", "testing"]
+            },
+            "data": {
+                "users": {
+                    "count": 100,
+                    "active": 80
+                }
+            },
+            "config": {
+                "debug": False
+            }
+        }
+        d2 = {
+            "metadata": {
+                "version": "2.0",
+                "tags": ["python", "testing", "advanced"]
+            },
+            "data": {
+                "users": {
+                    "active": 90
+                },
+                "posts": {
+                    "count": 200
+                }
+            },
+            "config": {}
+        }
+
+        result = recursive_dict_merge(d1, d2)
+
+        assert result == {
+            "metadata": {
+                "version": "2.0",
+                "author": "Alice",
+                "tags": ["python", "testing", "advanced"]
+            },
+            "data": {
+                "users": {
+                    "count": 100,
+                    "active": 90
+                },
+                "posts": {
+                    "count": 200
+                }
+            },
+            "config": {}
+        }
+
+
+class TestExtractJqDeletionPathRevised:
+    """Tests for extract_jq_deletion_path_revised function."""
+
+    def test_simple_path(self) -> None:
+        """Test extraction of simple path like .key."""
+        result = extract_jq_deletion_path_revised(".file.content")
+        assert result == ".file.content"
+
+    def test_simple_single_key(self) -> None:
+        """Test extraction of single key path."""
+        result = extract_jq_deletion_path_revised(".key")
+        assert result == ".key"
+
+    def test_nested_path(self) -> None:
+        """Test extraction of nested path."""
+        result = extract_jq_deletion_path_revised(".file.content.raw")
+        assert result == ".file.content.raw"
+
+    def test_path_with_parentheses(self) -> None:
+        """Test extraction with surrounding parentheses."""
+        result = extract_jq_deletion_path_revised("(.file.content)")
+        assert result == ".file.content"
+
+    def test_path_with_pipe_segments(self) -> None:
+        """Test extraction from pipe-separated expression."""
+        result = extract_jq_deletion_path_revised(". as $all | .file.content")
+        assert result == ".file.content"
+
+    def test_path_with_variable_assignment_ignored(self) -> None:
+        """Test that variable assignment segments are ignored."""
+        result = extract_jq_deletion_path_revised(". as $root | .file.content")
+        assert result == ".file.content"
+
+    def test_path_with_variable_access_ignored(self) -> None:
+        """Test that variable access like $items is ignored."""
+        result = extract_jq_deletion_path_revised("$items | .file.content")
+        assert result == ".file.content"
+
+    def test_identity_operator_ignored(self) -> None:
+        """Test that identity operator '.' is ignored."""
+        result = extract_jq_deletion_path_revised(". | .file.content")
+        assert result == ".file.content"
+
+    def test_path_with_fallback_operator(self) -> None:
+        """Test path extraction with fallback operator (//)."""
+        result = extract_jq_deletion_path_revised(".file.content // {}")
+        assert result == ".file.content"
+
+    def test_path_with_fallback_to_null(self) -> None:
+        """Test path extraction with fallback to null."""
+        result = extract_jq_deletion_path_revised(".file.content // null")
+        assert result == ".file.content"
+
+    def test_path_with_fallback_to_empty_array(self) -> None:
+        """Test path extraction with fallback to empty array."""
+        result = extract_jq_deletion_path_revised(".file.content // []")
+        assert result == ".file.content"
+
+    def test_path_with_fallback_to_object(self) -> None:
+        """Test path extraction with fallback to object."""
+        result = extract_jq_deletion_path_revised(".file.content // {}")
+        assert result == ".file.content"
+
+    def test_path_with_bracketed_accessor(self) -> None:
+        """Test path extraction with array index accessor."""
+        result = extract_jq_deletion_path_revised(".[0].key")
+        assert result == ".[0].key"
+
+    def test_path_with_multiple_bracketed_accessors(self) -> None:
+        """Test path extraction with multiple array index accessors."""
+        result = extract_jq_deletion_path_revised(".[0].[1].key")
+        assert result == ".[0].[1].key"
+
+    def test_path_with_mixed_accessors(self) -> None:
+        """Test path extraction with mixed key and bracket accessors."""
+        result = extract_jq_deletion_path_revised(".file[0].content")
+        assert result == ".file[0].content"
+
+    def test_path_with_mixed_accessors_with_dots(self) -> None:
+        """Test path extraction with mixed key and bracket accessors with dots."""
+        result = extract_jq_deletion_path_revised(".file.[0].content")
+        assert result == ".file.[0].content"
+
+    def test_complex_pipe_expression(self) -> None:
+        """Test extraction from complex pipe expression."""
+        result = extract_jq_deletion_path_revised(
+            ". as $all | ($all | .file.content) as $items | $items"
+        )
+        assert result == ".file.content"
+
+    def test_path_in_parentheses_with_pipes(self) -> None:
+        """Test path extraction from parenthesized expression with pipes."""
+        result = extract_jq_deletion_path_revised("(. as $all | .file.content)")
+        assert result == ".file.content"
+
+    def test_no_path_returns_none(self) -> None:
+        """Test that expression without path returns None."""
+        result = extract_jq_deletion_path_revised("$items")
+        assert result is None
+
+    def test_only_identity_returns_none(self) -> None:
+        """Test that expression with only identity operator returns None."""
+        result = extract_jq_deletion_path_revised(".")
+        assert result is None
+
+    def test_only_variable_returns_none(self) -> None:
+        """Test that expression with only variable returns None."""
+        result = extract_jq_deletion_path_revised("$items")
+        assert result is None
+
+    def test_only_variable_assignment_returns_none(self) -> None:
+        """Test that expression with only variable assignment returns None."""
+        result = extract_jq_deletion_path_revised(". as $root")
+        assert result is None
+
+    def test_malformed_parentheses_returns_none(self) -> None:
+        """Test that malformed parentheses return None."""
+        result = extract_jq_deletion_path_revised("(.file.content")
+        assert result is None
+
+    def test_whitespace_handling(self) -> None:
+        """Test that whitespace is properly handled."""
+        result = extract_jq_deletion_path_revised("  .file.content  ")
+        assert result == ".file.content"
+
+    def test_path_with_underscores(self) -> None:
+        """Test path extraction with underscores in keys."""
+        result = extract_jq_deletion_path_revised(".file_content.raw_data")
+        assert result == ".file_content.raw_data"
+
+    def test_path_with_numbers_in_keys(self) -> None:
+        """Test path extraction with numbers in keys."""
+        result = extract_jq_deletion_path_revised(".file2.content3")
+        assert result == ".file2.content3"
+
+    def test_deeply_nested_path(self) -> None:
+        """Test extraction of deeply nested path."""
+        result = extract_jq_deletion_path_revised(".a.b.c.d.e.f")
+        assert result == ".a.b.c.d.e.f"
+
+    def test_path_with_fallback_in_pipe(self) -> None:
+        """Test path extraction with fallback in pipe expression."""
+        result = extract_jq_deletion_path_revised(". as $all | .file.content // {}")
+        assert result == ".file.content"
+
+    def test_multiple_paths_returns_first(self) -> None:
+        """Test that first valid path is returned when multiple exist."""
+        result = extract_jq_deletion_path_revised(".first.path | .second.path")
+        assert result == ".first.path"
+
+    def test_path_with_complex_bracket_expression(self) -> None:
+        """Test path extraction with complex bracket expression."""
+        result = extract_jq_deletion_path_revised(".[\"key\"].value")
+        assert result == ".[\"key\"].value"
+
+    def test_empty_string_returns_none(self) -> None:
+        """Test that empty string returns None."""
+        result = extract_jq_deletion_path_revised("")
+        assert result is None
+
+    def test_whitespace_only_returns_none(self) -> None:
+        """Test that whitespace-only string returns None."""
+        result = extract_jq_deletion_path_revised("   ")
+        assert result is None
+
+    def test_real_world_file_content_path(self) -> None:
+        """Test real-world scenario: file.content path."""
+        result = extract_jq_deletion_path_revised(".file.content.raw")
+        assert result == ".file.content.raw"
+
+    def test_real_world_with_variable_and_fallback(self) -> None:
+        """Test real-world scenario with variable and fallback."""
+        result = extract_jq_deletion_path_revised(
+            ". as $all | ($all | .file.content.raw) // {}"
+        )
+        assert result == ".file.content.raw"

{port_ocean-0.30.4.dist-info → port_ocean-0.30.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.30.4
+Version: 0.30.5
 Summary: Port Ocean is a CLI tool for managing your Port projects.
 Home-page: https://app.getport.io
 Keywords: ocean,port-ocean,port

{port_ocean-0.30.4.dist-info → port_ocean-0.30.5.dist-info}/RECORD

@@ -130,7 +130,7 @@ port_ocean/core/integrations/mixins/handler.py,sha256=mZ7-0UlG3LcrwJttFbMe-R4xcO
 port_ocean/core/integrations/mixins/live_events.py,sha256=zM24dhNc7uHx9XYZ6toVhDADPA90EnpOmZxgDegFZbA,4196
 port_ocean/core/integrations/mixins/sync.py,sha256=Vm_898pLKBwfVewtwouDWsXoxcOLicnAy6pzyqqk6U8,4053
 port_ocean/core/integrations/mixins/sync_raw.py,sha256=kcL7flnQ25E3KKyo6L3aL9wSzgBtoWYzgQjS4uRbDOs,42612
-port_ocean/core/integrations/mixins/utils.py,sha256=JegPuIQGBXMnywHBIX30i7gYz0gY7_bW_Jx5LUuQM9c,13718
+port_ocean/core/integrations/mixins/utils.py,sha256=nvLxzbRqOpbVhpI0xbKczrTCtLcR0HysFxck9b1BBy0,17425
 port_ocean/core/models.py,sha256=8ZNEmM3Nq0VSB3fYJVgEdJVjJmaGjMnng-bm-ZBbTNg,3695
 port_ocean/core/ocean_types.py,sha256=bkLlTd8XfJK6_JDl0eXUHfE_NygqgiInSMwJ4YJH01Q,1399
 port_ocean/core/utils/entity_topological_sorter.py,sha256=MDUjM6OuDy4Xj68o-7InNN0w1jqjxeDfeY8U02vySNI,3081
@@ -191,6 +191,7 @@ port_ocean/tests/core/handlers/queue/test_local_queue.py,sha256=9Ly0HzZXbs6Rbl_b
 port_ocean/tests/core/handlers/webhook/test_abstract_webhook_processor.py,sha256=zKwHhPAYEZoZ5Z2UETp1t--mbkS8uyvlXThB0obZTTc,3340
 port_ocean/tests/core/handlers/webhook/test_processor_manager.py,sha256=wKzKO79HByqtLcKoYUQ6PjZ-VZAUT1TwdZXyH9NchfY,52365
 port_ocean/tests/core/handlers/webhook/test_webhook_event.py,sha256=oR4dEHLO65mp6rkfNfszZcfFoRZlB8ZWee4XetmsuIk,3181
+port_ocean/tests/core/integrations/mixins/test_integration_utils.py,sha256=MDNCnx5V_XVmUgeJB68Mwpm57_fbpWksijKe7aTMU4k,17552
 port_ocean/tests/core/test_utils.py,sha256=Z3kdhb5V7Svhcyy3EansdTpgHL36TL6erNtU-OPwAcI,2647
 port_ocean/tests/core/utils/test_entity_topological_sorter.py,sha256=zuq5WSPy_88PemG3mOUIHTxWMR_js1R7tOzUYlgBd68,3447
 port_ocean/tests/core/utils/test_get_port_diff.py,sha256=YoQxAHZdX5nVpvrKV5Aox-jQ4w14AbfJVo-QK-ICAb8,4297
@@ -221,8 +222,8 @@ port_ocean/utils/repeat.py,sha256=U2OeCkHPWXmRTVoPV-VcJRlQhcYqPWI5NfmPlb1JIbc,32
 port_ocean/utils/signal.py,sha256=J1sI-e_32VHP_VUa5bskLMFoJjJOAk5isrnewKDikUI,2125
 port_ocean/utils/time.py,sha256=pufAOH5ZQI7gXvOvJoQXZXZJV-Dqktoj9Qp9eiRwmJ4,1939
 port_ocean/version.py,sha256=UsuJdvdQlazzKGD3Hd5-U7N69STh8Dq9ggJzQFnu9fU,177
-port_ocean-0.30.4.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.30.4.dist-info/METADATA,sha256=V6JgHyFwlUviArX3z3Wch_wzNtrPi8HZ1prwThOOKzY,7095
-port_ocean-0.30.4.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-port_ocean-0.30.4.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.30.4.dist-info/RECORD,,
+port_ocean-0.30.5.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.30.5.dist-info/METADATA,sha256=bTE9t8Hx2DR2YUvA0RGM3AGwdvmYn3mCXTxJUJL66UU,7095
+port_ocean-0.30.5.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+port_ocean-0.30.5.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.30.5.dist-info/RECORD,,