ethyca-fides 2.70.4b0__tar.gz → 2.70.5b0__tar.gz

{ethyca_fides-2.70.4b0/src/ethyca_fides.egg-info → ethyca_fides-2.70.5b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ethyca_fides
-Version: 2.70.4b0
+Version: 2.70.5b0
 Summary: Open-source ecosystem for data privacy as code.
 Home-page: https://github.com/ethyca/fides
 Author: Ethyca, Inc.

{ethyca_fides-2.70.4b0 → ethyca_fides-2.70.5b0/src/ethyca_fides.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ethyca_fides
-Version: 2.70.4b0
+Version: 2.70.5b0
 Summary: Open-source ecosystem for data privacy as code.
 Home-page: https://github.com/ethyca/fides
 Author: Ethyca, Inc.

{ethyca_fides-2.70.4b0 → ethyca_fides-2.70.5b0}/src/ethyca_fides.egg-info/SOURCES.txt

@@ -220,6 +220,7 @@ src/fides/api/alembic/migrations/versions/9b98aba5bba8_remove_consent_settings.p
 src/fides/api/alembic/migrations/versions/9c6f62e4c9da_make_datasetconfig_ctl_datasets_non_nullable.py
 src/fides/api/alembic/migrations/versions/9cad5a5c438c_update_stagedresource_chid_diff_statuses_booleans_data.py
 src/fides/api/alembic/migrations/versions/9de4bb76307a_add_dynamic_erasure_email_connector_type.py
+src/fides/api/alembic/migrations/versions/9e0dcbf67b9f_add_digest_config.py
 src/fides/api/alembic/migrations/versions/9e3dab26f75f_add_test_website_to_connectiontype.py
 src/fides/api/alembic/migrations/versions/9e83545ed9b6_pre_approval_webhook_cleanup.py
 src/fides/api/alembic/migrations/versions/9f38dad37628_redo_roles_scopes_mapping.py
@@ -469,6 +470,9 @@ src/fides/api/models/detection_discovery/classification_benchmark.py
 src/fides/api/models/detection_discovery/core.py
 src/fides/api/models/detection_discovery/monitor_task.py
 src/fides/api/models/detection_discovery/web_monitor.py
+src/fides/api/models/digest/__init__.py
+src/fides/api/models/digest/conditional_dependencies.py
+src/fides/api/models/digest/digest_config.py
 src/fides/api/models/field_types/__init__.py
 src/fides/api/models/field_types/encrypted_large_data.py
 src/fides/api/models/manual_task/__init__.py
@@ -756,6 +760,8 @@ src/fides/api/task/conditional_dependencies/evaluator.py
 src/fides/api/task/conditional_dependencies/logging_utils.py
 src/fides/api/task/conditional_dependencies/operators.py
 src/fides/api/task/conditional_dependencies/schemas.py
+src/fides/api/task/conditional_dependencies/sql_schemas.py
+src/fides/api/task/conditional_dependencies/sql_translator.py
 src/fides/api/task/manual/__init__.py
 src/fides/api/task/manual/manual_task_address.py
 src/fides/api/task/manual/manual_task_conditional_evaluation.py
@@ -1014,7 +1020,7 @@ src/fides/ui-build/static/admin/_next/static/chunks/main-app-59156a9331ac7bce.js
 src/fides/ui-build/static/admin/_next/static/chunks/polyfills-42372ed130431b0a.js
 src/fides/ui-build/static/admin/_next/static/chunks/webpack-2766492c5dbceb0a.js
 src/fides/ui-build/static/admin/_next/static/chunks/pages/404-2eb8aed4939f1142.js
-src/fides/ui-build/static/admin/_next/static/chunks/pages/_app-de41f80e35acbde0.js
+src/fides/ui-build/static/admin/_next/static/chunks/pages/_app-a9d053921092de16.js
 src/fides/ui-build/static/admin/_next/static/chunks/pages/_error-bede3a8288930dcf.js
 src/fides/ui-build/static/admin/_next/static/chunks/pages/add-systems-caff552fce501f82.js
 src/fides/ui-build/static/admin/_next/static/chunks/pages/consent-d2bf72508c3cad55.js
@@ -1112,8 +1118,6 @@ src/fides/ui-build/static/admin/_next/static/css/95ac327e5d70148d.css
 src/fides/ui-build/static/admin/_next/static/css/972dc7eef106ee7c.css
 src/fides/ui-build/static/admin/_next/static/css/98fab0b3e6aa43ed.css
 src/fides/ui-build/static/admin/_next/static/css/d2d4e9a6923e6730.css
-src/fides/ui-build/static/admin/_next/static/gAyR6aUQCeUTA_oMVYpBp/_buildManifest.js
-src/fides/ui-build/static/admin/_next/static/gAyR6aUQCeUTA_oMVYpBp/_ssgManifest.js
 src/fides/ui-build/static/admin/_next/static/media/inter-all-400-normal.2ae8ed37.woff
 src/fides/ui-build/static/admin/_next/static/media/inter-all-500-normal.56c3d87b.woff
 src/fides/ui-build/static/admin/_next/static/media/inter-all-600-normal.d9666969.woff
@@ -1147,6 +1151,8 @@ src/fides/ui-build/static/admin/_next/static/media/inter-vietnamese-500-normal.7
 src/fides/ui-build/static/admin/_next/static/media/inter-vietnamese-600-normal.eb82de1d.woff2
 src/fides/ui-build/static/admin/_next/static/media/inter-vietnamese-700-normal.00e401a9.woff2
 src/fides/ui-build/static/admin/_next/static/media/logo-white.c9bf4196.svg
+src/fides/ui-build/static/admin/_next/static/uFcubrjoFrTUGQFZXt15O/_buildManifest.js
+src/fides/ui-build/static/admin/_next/static/uFcubrjoFrTUGQFZXt15O/_ssgManifest.js
 src/fides/ui-build/static/admin/add-systems/manual.html
 src/fides/ui-build/static/admin/add-systems/multiple.html
 src/fides/ui-build/static/admin/consent/configure.html

{ethyca_fides-2.70.4b0 → ethyca_fides-2.70.5b0}/src/fides/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-09-19T20:04:33-0700",
+ "date": "2025-09-23T16:10:27-0300",
  "dirty": false,
  "error": null,
- "full-revisionid": "7d75c55b554558c9b15ee8280920b4be4f7ee2f0",
- "version": "2.70.4b0"
+ "full-revisionid": "8b238061001b27210142e349894f696a9e163e36",
+ "version": "2.70.5b0"
 }
 '''  # END VERSION_JSON
 

ethyca_fides-2.70.5b0/src/fides/api/alembic/migrations/versions/9e0dcbf67b9f_add_digest_config.py

@@ -0,0 +1,84 @@
+"""add digest config
+
+Revision ID: 9e0dcbf67b9f
+Revises: cd8649be3a2b
+Create Date: 2025-09-22 20:23:48.258509
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = "9e0dcbf67b9f"
+down_revision = "cd8649be3a2b"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.create_table(
+        "digest_config",
+        sa.Column("id", sa.String(length=255), nullable=False),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=True,
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=True,
+        ),
+        sa.Column("digest_type", sa.String(length=255), nullable=False),
+        sa.Column("name", sa.String(length=255), nullable=False),
+        sa.Column("description", sa.Text(), nullable=True),
+        sa.Column("enabled", sa.Boolean(), nullable=False),
+        sa.Column("messaging_service_type", sa.String(length=255), nullable=False),
+        sa.Column("cron_expression", sa.String(length=100), nullable=False),
+        sa.Column("timezone", sa.String(length=50), nullable=False),
+        sa.Column("last_sent_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("next_scheduled_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column(
+            "config_metadata", postgresql.JSONB(astext_type=sa.Text()), nullable=True
+        ),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(
+        op.f("ix_digest_config_digest_type"),
+        "digest_config",
+        ["digest_type"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_digest_config_enabled"), "digest_config", ["enabled"], unique=False
+    )
+    op.create_index(op.f("ix_digest_config_id"), "digest_config", ["id"], unique=False)
+    op.create_index(
+        op.f("ix_digest_config_messaging_service_type"),
+        "digest_config",
+        ["messaging_service_type"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_digest_config_next_scheduled_at"),
+        "digest_config",
+        ["next_scheduled_at"],
+        unique=False,
+    )
+
+
+def downgrade():
+    op.drop_index(
+        op.f("ix_digest_config_next_scheduled_at"), table_name="digest_config"
+    )
+    op.drop_index(
+        op.f("ix_digest_config_messaging_service_type"), table_name="digest_config"
+    )
+    op.drop_index(op.f("ix_digest_config_id"), table_name="digest_config")
+    op.drop_index(op.f("ix_digest_config_enabled"), table_name="digest_config")
+    op.drop_index(op.f("ix_digest_config_digest_type"), table_name="digest_config")
+    op.drop_table("digest_config")

{ethyca_fides-2.70.4b0 → ethyca_fides-2.70.5b0}/src/fides/api/db/base.py

@@ -22,6 +22,7 @@ from fides.api.models.detection_discovery.monitor_task import (
     MonitorTaskExecutionLog,
 )
 from fides.api.models.detection_discovery.web_monitor import WebMonitorGroupJob
+from fides.api.models.digest import DigestConfig
 from fides.api.models.event_audit import EventAudit
 from fides.api.models.experience_notices import ExperienceNotices
 from fides.api.models.fides_cloud import FidesCloud

ethyca_fides-2.70.5b0/src/fides/api/models/digest/__init__.py

@@ -0,0 +1,10 @@
+"""Digest models package."""
+
+from fides.api.models.digest.conditional_dependencies import DigestConditionType
+from fides.api.models.digest.digest_config import DigestConfig, DigestType
+
+__all__ = [
+    "DigestConfig",
+    "DigestType",
+    "DigestConditionType",
+]

ethyca_fides-2.70.5b0/src/fides/api/models/digest/conditional_dependencies.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class DigestConditionType(str, Enum):
+    """Types of digest conditions - each can have their own tree."""
+
+    RECEIVER = "receiver"
+    CONTENT = "content"
+    PRIORITY = "priority"

ethyca_fides-2.70.5b0/src/fides/api/models/digest/digest_config.py

@@ -0,0 +1,76 @@
+from enum import Enum
+from typing import Optional, Union
+
+from sqlalchemy import Boolean, Column, DateTime, String, Text
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.ext.declarative import declared_attr
+from sqlalchemy.orm import Session
+
+from fides.api.db.base_class import Base
+from fides.api.db.util import EnumColumn
+from fides.api.models.digest.conditional_dependencies import DigestConditionType
+from fides.api.schemas.messaging.messaging import MessagingMethod
+from fides.api.task.conditional_dependencies.schemas import (
+    Condition,
+    ConditionGroup,
+    ConditionLeaf,
+)
+
+
+class DigestType(str, Enum):
+    """Types of digests that can be configured."""
+
+    MANUAL_TASKS = "manual_tasks"
+    PRIVACY_REQUESTS = "privacy_requests"
+    # More types can be added here
+
+
+class DigestConfig(Base):
+    """Generic configuration for any type of digest."""
+
+    @declared_attr
+    def __tablename__(cls) -> str:
+        return "digest_config"
+
+    # Digest identification
+    digest_type = Column(EnumColumn(DigestType), nullable=False, index=True)
+    name = Column(String(255), nullable=False)
+    description = Column(Text, nullable=True)
+
+    # Configuration
+    enabled = Column(Boolean, nullable=False, default=True, index=True)
+    messaging_service_type = Column(
+        EnumColumn(MessagingMethod),
+        nullable=False,
+        default=MessagingMethod.EMAIL,
+        index=True,
+    )
+    cron_expression = Column(String(100), nullable=False, default="0 9 * * 1")
+    timezone = Column(String(50), nullable=False, default="US/Eastern")
+    last_sent_at = Column(DateTime(timezone=True), nullable=True)
+    next_scheduled_at = Column(DateTime(timezone=True), nullable=True, index=True)
+    config_metadata = Column(JSONB, nullable=True, default={})
+
+    def get_receiver_conditions(
+        self, db: Session
+    ) -> Optional[Union[ConditionLeaf, ConditionGroup]]:
+        """Get receiver conditions for this digest config."""
+        raise NotImplementedError("Conditions are not implemented for digests")
+
+    def get_content_conditions(
+        self, db: Session
+    ) -> Optional[Union[ConditionLeaf, ConditionGroup]]:
+        """Get content conditions for this digest config."""
+        raise NotImplementedError("Conditions are not implemented for digests")
+
+    def get_priority_conditions(
+        self, db: Session
+    ) -> Optional[Union[ConditionLeaf, ConditionGroup]]:
+        """Get priority conditions for this digest config."""
+        raise NotImplementedError("Conditions are not implemented for digests")
+
+    def get_all_conditions(
+        self, db: Session
+    ) -> dict["DigestConditionType", Optional[Condition]]:
+        """Get all condition types for this digest config."""
+        raise NotImplementedError("Conditions are not implemented for digests")

{ethyca_fides-2.70.4b0 → ethyca_fides-2.70.5b0}/src/fides/api/models/privacy_notice.py

@@ -191,16 +191,36 @@ class PrivacyNotice(PrivacyNoticeBase, Base):
 
     @property
     def cookies(self) -> List[Asset]:
-        """Return relevant assets of type 'cookie' (via the data use)"""
+        """
+        Return the privacy notice's assets of type 'cookie'.
+        Cookies are matched to the privacy notice if they have at least one data use
+        that is either an exact match or a hierarchical descendant of a one of the
+        data uses in the privacy notice.
+        """
         db = Session.object_session(self)
-        or_queries = [
-            f"array_to_string(data_uses, ',') ILIKE '{data_use}%'"
-            for data_use in self.data_uses
+
+        if not self.data_uses:
+            return []
+
+        # Use array overlap operator (&&) for exact matches - GIN index friendly
+        exact_matches_condition = Asset.data_uses.op("&&")(self.data_uses)
+
+        # For hierarchical children, we still need to check individual elements with LIKE
+        # They have to match the data_use and the period separator, so we know it's a hierarchical descendant
+        hierarchical_conditions = [
+            text(
+                f"EXISTS(SELECT 1 FROM unnest(data_uses) AS data_use WHERE data_use LIKE :pattern_{i})"
+            ).bindparams(**{f"pattern_{i}": f"{data_use}.%"})
+            for i, data_use in enumerate(self.data_uses)
         ]
 
+        asset_matching_condition = or_(
+            exact_matches_condition, *hierarchical_conditions
+        )
+
         query = db.query(Asset).filter(
             Asset.asset_type == "Cookie",
-            or_(*[text(query) for query in or_queries]),
+            asset_matching_condition,
         )
 
         return query.all()

ethyca_fides-2.70.5b0/src/fides/api/task/conditional_dependencies/sql_schemas.py

@@ -0,0 +1,301 @@
+import types
+import uuid
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+from sqlalchemy import Column, any_, bindparam
+
+from fides.api.task.conditional_dependencies.schemas import Operator
+
+
+class SQLTranslationError(Exception):
+    """Error raised when SQL translation fails"""
+
+
+def _escape_like_pattern(val: Any) -> str:
+    """
+    Escape LIKE wildcards in user input to prevent pattern injection attacks.
+
+    This prevents users from injecting wildcards (% and _) that could:
+    - Match unintended records through pattern injection
+    - Cause performance issues with expensive wildcard operations
+    - Enable information disclosure through pattern probing
+
+    Note: This function escapes ALL % and _ characters as a security measure.
+    While this may seem aggressive for normal field names, it's necessary because:
+    1. We can't distinguish between intentional and malicious wildcards
+    2. Field values shouldn't typically contain SQL wildcards
+    3. Better to be overly cautious with user input
+
+    Args:
+        val: User input value to escape
+
+    Returns:
+        Escaped string safe for use in LIKE patterns
+
+    Examples:
+        _escape_like_pattern("admin%") -> "admin\\%"
+        _escape_like_pattern("test_user") -> "test\\_user"  # Escapes _ for security
+        _escape_like_pattern("normal") -> "normal"
+    """
+    if val is None:
+        return ""
+
+    val_str = str(val)
+    # Escape backslashes first to prevent double-escaping
+    # Then escape LIKE wildcards (% and _)
+    return val_str.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+
+
+def _validate_and_escape_json_path_component(component: str) -> str:
+    """
+    Validate and escape JSON path components to prevent injection attacks.
+
+    This prevents users from injecting malicious content in JSON path components that could:
+    - Break out of single quotes in PostgreSQL JSON operators
+    - Inject arbitrary SQL through malformed JSON paths
+    - Cause syntax errors or unexpected behavior
+
+    Args:
+        component: JSON path component to validate and escape
+
+    Returns:
+        Validated and escaped component safe for use in PostgreSQL JSON operators
+
+    Raises:
+        SQLTranslationError: If the component contains invalid characters
+
+    Examples:
+        _validate_and_escape_json_path_component("field") -> "field"
+        _validate_and_escape_json_path_component("field'name") -> "field''name"
+        _validate_and_escape_json_path_component("") -> raises SQLTranslationError
+    """
+    if not component or not isinstance(component, str):
+        raise SQLTranslationError(
+            f"Invalid JSON path component: '{component}'. Components must be non-empty strings."
+        )
+
+    # Check for potentially dangerous characters
+    if len(component) > 100:  # Reasonable limit for JSON field names
+        raise SQLTranslationError(
+            f"JSON path component too long: '{component[:50]}...'. Maximum length is 100 characters."
+        )
+
+    # Escape single quotes for PostgreSQL JSON operators (double them)
+    escaped_component = component.replace("'", "''")
+
+    return escaped_component
+
+
+def _handle_list_contains(col: Column, val: Any) -> Column:
+    """
+    Handle list_contains operator for different scenarios:
+    - If val is a list: check if column value is IN the list
+    - If val is a single value: check if column contains the value (for arrays/JSON) or use LIKE (for strings)
+
+    Args:
+        col: SQLAlchemy column
+        val: Value to compare against
+
+    Returns:
+        SQLAlchemy expression for the comparison
+    """
+    if isinstance(val, list):
+        # If value is a list, check if column value is IN the list
+        return col.in_(val)
+
+    # For single values, we need to handle different column types
+    # Check if this is a PostgreSQL array column
+    if hasattr(col.type, "item_type") or str(col.type).startswith("ARRAY"):
+        # This is a PostgreSQL array - use the ANY operator with proper parameter binding
+        # This is safer and prevents SQL injection
+        # Generate unique parameter name to avoid conflicts when multiple list operations exist in same query
+        unique_param_name = f"array_val_{uuid.uuid4().hex[:8]}"
+        param = bindparam(unique_param_name, val)
+        return param == any_(col)
+
+    # Try JSON containment for JSONB/JSON columns
+    try:
+        return col.contains(val)
+    except Exception:
+        # Fallback to LIKE for string columns with escaped wildcards
+        escaped_val = _escape_like_pattern(val)
+        return col.like(f"%{escaped_val}%", escape="\\")
+
+
+OPERATOR_MAP = types.MappingProxyType(
+    {
+        Operator.eq: lambda col, val: col == val,
+        Operator.neq: lambda col, val: col != val,
+        Operator.lt: lambda col, val: col < val,
+        Operator.lte: lambda col, val: col <= val,
+        Operator.gt: lambda col, val: col > val,
+        Operator.gte: lambda col, val: col >= val,
+        Operator.contains: lambda col, val: col.like(
+            f"%{_escape_like_pattern(val)}%", escape="\\"
+        ),
+        Operator.starts_with: lambda col, val: col.like(
+            f"{_escape_like_pattern(val)}%", escape="\\"
+        ),
+        Operator.ends_with: lambda col, val: col.like(
+            f"%{_escape_like_pattern(val)}", escape="\\"
+        ),
+        Operator.exists: lambda col, val: col.isnot(None),
+        Operator.not_exists: lambda col, val: col.is_(None),
+        Operator.list_contains: _handle_list_contains,
+        Operator.not_in_list: lambda col, val: ~_handle_list_contains(col, val),
+    }
+)
+
+
+class FieldAddress(BaseModel):
+    """Parsed field address with table and column information"""
+
+    table_name: str = Field(description="Table name extracted from field address")
+    column_name: str = Field(description="Base column name without JSON path")
+    json_path: Optional[list[str]] = Field(
+        default=None, description="JSON path components if this is a JSON field"
+    )
+    full_address: str = Field(description="Original field address string")
+
+    def __hash__(self) -> int:
+        """Make FieldAddress hashable for use in sets"""
+        return hash(
+            (
+                self.table_name,
+                self.column_name,
+                tuple(self.json_path) if self.json_path else None,
+            )
+        )
+
+    def __eq__(self, other: Any) -> bool:
+        """Enable equality comparison for FieldAddress objects"""
+        if not isinstance(other, FieldAddress):
+            return False
+        return (
+            self.table_name == other.table_name
+            and self.column_name == other.column_name
+            and self.json_path == other.json_path
+        )
+
+    def to_sql_column(self, enable_json_operators: bool = True) -> str:
+        """
+        Convert field address to PostgreSQL column reference
+
+        Args:
+            enable_json_operators: Whether to use PostgreSQL JSON operators for JSON paths
+
+        Returns:
+            SQL column reference string
+        """
+        is_json_path = self.json_path is not None and len(self.json_path) > 0
+        if not is_json_path or not enable_json_operators:
+            return self.column_name
+
+        if self.json_path is None:
+            # This should never happen
+            raise SQLTranslationError(
+                "Field address internal error."
+            )  # pragma: no cover
+
+        # Build PostgreSQL JSON path: column->'path'->'path'->>'final_path'
+        # Validate and escape all components to prevent injection
+        if self.json_path and len(self.json_path) == 1:
+            # Simple case: column->>'field'
+            escaped_component = _validate_and_escape_json_path_component(
+                self.json_path[0]
+            )
+            return f"{self.column_name}->>'{escaped_component}'"
+
+        # Complex case: column->'field'->'field'->>'final_field'
+        path_parts = []
+        # All but last use -> operator
+        for part in self.json_path[:-1]:
+            escaped_part = _validate_and_escape_json_path_component(part)
+            path_parts.append(f"->'{escaped_part}'")
+        # Last part uses ->> operator (returns text)
+        escaped_final = _validate_and_escape_json_path_component(self.json_path[-1])
+        path_parts.append(f"->>'{escaped_final}'")
+
+        return f"{self.column_name}{''.join(path_parts)}"
+
+    @classmethod
+    def _parse_parts_to_components(
+        cls, parts: list[str]
+    ) -> tuple[str, str, Optional[list[str]]]:
+        """
+        Parse a list of parts into table_name, column_name, and json_path components.
+
+        Args:
+            parts: List of address parts (e.g., ["table", "column", "path1", "path2"])
+
+        Returns:
+            Tuple of (table_name, column_name, json_path)
+        """
+        if len(parts) < 2:
+            return "", parts[0] if parts else "", None
+
+        table_name = parts[0]
+        column_name = parts[1]
+        json_path = parts[2:] if len(parts) > 2 else None
+
+        return table_name, column_name, json_path
+
+    @classmethod
+    def parse(cls, field_address: str) -> "FieldAddress":
+        """
+        Parse a field address into components
+
+        Supports formats:
+        - "table.column" -> table="table", column="column"
+        - "table.json_column.path.subpath" -> table="table", column="json_column", json_path=["path", "subpath"]
+        - "table:column" -> table="table", column="column" (alternative format)
+        - "column" -> table="", column="column" (requires default table)
+        """
+        if ":" in field_address:
+            # Format: table:column or dataset:collection:field
+            # Handle colon-separated format first, then check for dots in the remaining parts
+            colon_parts = field_address.split(":")
+            if len(colon_parts) >= 2:
+                table_name = colon_parts[0]
+                remaining = ":".join(colon_parts[1:])  # Join remaining parts
+
+                # Check if the remaining part has dots (JSON path)
+                if "." in remaining:
+                    # Mixed format: table:column.path1.path2
+                    dot_parts = remaining.split(".")
+                    parts = [table_name] + dot_parts
+                else:
+                    # Pure colon format: table:column or table:column:path1:path2
+                    parts = colon_parts
+
+                table_name, column_name, json_path = cls._parse_parts_to_components(
+                    parts
+                )
+
+                return cls(
+                    table_name=table_name,
+                    column_name=column_name,
+                    json_path=json_path,
+                    full_address=field_address,
+                )
+
+        if "." in field_address:
+            # Format: table.column or table.json_column.path.subpath
+            parts = field_address.split(".")
+            table_name, column_name, json_path = cls._parse_parts_to_components(parts)
+
+            return cls(
+                table_name=table_name,
+                column_name=column_name,
+                json_path=json_path,
+                full_address=field_address,
+            )
+
+        # Simple column name without table
+        return cls(
+            table_name="",  # Will need default table
+            column_name=field_address,
+            json_path=None,
+            full_address=field_address,
+        )