omnibase_infra 0.2.9__py3-none-any.whl → 0.3.0__py3-none-any.whl

omnibase_infra/runtime/db/postgres_repository_runtime.py

@@ -0,0 +1,545 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""PostgreSQL Repository Runtime.
+
+This module provides a generic runtime for executing repository contracts
+against PostgreSQL databases. The runtime enforces safety constraints,
+deterministic query ordering, and configurable operation limits.
+
+Key Features:
+    - Contract-driven: All operations defined in ModelDbRepositoryContract
+    - Positional parameters: Uses $1, $2, ... (no named param rewriting)
+    - Determinism enforcement: ORDER BY injection for multi-row queries
+    - Limit enforcement: LIMIT injection with configurable maximum
+    - Operation validation: Allowlist-based operation control
+    - Timeout enforcement: asyncio.wait_for() for query cancellation
+
+Usage Example:
+    >>> import asyncpg
+    >>> from omnibase_infra.runtime.db import (
+    ...     ModelDbRepositoryContract,
+    ...     ModelDbOperation,
+    ...     ModelDbReturn,
+    ...     ModelRepositoryRuntimeConfig,
+    ... )
+    >>> from omnibase_infra.runtime.db.postgres_repository_runtime import (
+    ...     PostgresRepositoryRuntime,
+    ... )
+    >>>
+    >>> # Create contract
+    >>> contract = ModelDbRepositoryContract(
+    ...     name="users",
+    ...     database_ref="primary",
+    ...     ops={
+    ...         "find_by_id": ModelDbOperation(
+    ...             mode="select",
+    ...             sql="SELECT * FROM users WHERE id = $1",
+    ...             params=["user_id"],
+    ...             returns=ModelDbReturn(many=False),
+    ...         ),
+    ...     },
+    ... )
+    >>>
+    >>> # Create runtime (with pool)
+    >>> pool = await asyncpg.create_pool(...)
+    >>> runtime = PostgresRepositoryRuntime(pool, contract)
+    >>>
+    >>> # Execute operation
+    >>> user = await runtime.call("find_by_id", 123)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+import time
+from typing import TYPE_CHECKING
+
+from omnibase_infra.enums import EnumInfraTransportType
+from omnibase_infra.errors.repository import (
+    RepositoryContractError,
+    RepositoryExecutionError,
+    RepositoryTimeoutError,
+    RepositoryValidationError,
+)
+from omnibase_infra.models.errors import ModelInfraErrorContext
+from omnibase_infra.runtime.db.models import (
+    ModelDbOperation,
+    ModelDbRepositoryContract,
+    ModelRepositoryRuntimeConfig,
+)
+
+if TYPE_CHECKING:
+    import asyncpg
+
+logger = logging.getLogger(__name__)
+
+# =============================================================================
+# SQL Clause Detection Patterns
+# =============================================================================
+#
+# These regex patterns provide simple ORDER BY and LIMIT clause detection
+# for determinism enforcement. They use word boundaries (\b) and case-insensitive
+# matching to identify SQL keywords.
+#
+# KNOWN LIMITATIONS:
+# -----------------
+# These patterns use simple regex matching, NOT a full SQL parser. As such,
+# they can produce false positives in certain edge cases:
+#
+# 1. String Literals: Patterns inside quoted strings will match:
+#    - SELECT description FROM items WHERE note = 'sort ORDER BY priority'
+#    - SELECT * FROM logs WHERE message LIKE '%LIMIT 10 reached%'
+#
+# 2. Subqueries: Patterns in nested queries will match the outer detection:
+#    - SELECT * FROM (SELECT id FROM users ORDER BY created_at LIMIT 5) sub
+#    - The outer query appears to have ORDER BY/LIMIT, but doesn't
+#
+# 3. Comments: Patterns inside SQL comments will match:
+#    - SELECT * FROM users -- ORDER BY id for debugging
+#    - SELECT * FROM users /* LIMIT 100 was here */
+#
+# WHY THIS IS ACCEPTABLE:
+# ----------------------
+# 1. Contract SQL should be simple, predictable queries. Complex queries with
+#    subqueries, dynamic string construction, or embedded SQL in literals
+#    indicate contract design that should be reconsidered.
+#
+# 2. This detection is defense-in-depth, not primary validation. The contract
+#    author has explicit control over the SQL and can always add explicit
+#    ORDER BY and LIMIT clauses to avoid injection entirely.
+#
+# 3. False positives (detecting ORDER BY/LIMIT when not present at outer level)
+#    are safer than false negatives. A false positive skips injection, leaving
+#    the query unchanged. A false negative would inject duplicate clauses.
+#
+# RECOMMENDATION FOR COMPLEX QUERIES:
+# ----------------------------------
+# If your contract requires complex SQL with subqueries or string operations
+# that contain SQL keywords, explicitly include ORDER BY and LIMIT in the
+# outer query. This bypasses regex detection entirely:
+#
+#   GOOD: "SELECT * FROM (SELECT id FROM users ORDER BY id) sub ORDER BY id LIMIT 100"
+#   AVOID: Relying on injection for queries with embedded SQL-like strings
+#
+# =============================================================================
+_ORDER_BY_PATTERN = re.compile(r"\bORDER\s+BY\b", re.IGNORECASE)
+_LIMIT_PATTERN = re.compile(r"\bLIMIT\s+(\d+)\b", re.IGNORECASE)
+
+
+class PostgresRepositoryRuntime:
+    """Runtime for executing repository contracts against PostgreSQL.
+
+    Executes operations defined in a ModelDbRepositoryContract with
+    safety constraints, determinism guarantees, and configurable limits.
+
+    Thread Safety:
+        This class is NOT thread-safe for concurrent modifications.
+        The pool itself handles connection-level concurrency.
+        Multiple coroutines may call() concurrently on the same runtime.
+
+    Attributes:
+        pool: asyncpg connection pool for database access.
+        contract: Repository contract defining available operations.
+        config: Runtime configuration for safety and behavior.
+
+    Example:
+        >>> pool = await asyncpg.create_pool(dsn="postgresql://...")
+        >>> runtime = PostgresRepositoryRuntime(pool, contract)
+        >>> results = await runtime.call("find_all")
+    """
+
+    __slots__ = ("_config", "_contract", "_pool")
+
+    def __init__(
+        self,
+        pool: asyncpg.Pool,
+        contract: ModelDbRepositoryContract,
+        config: ModelRepositoryRuntimeConfig | None = None,
+    ) -> None:
+        """Initialize the repository runtime.
+
+        Args:
+            pool: asyncpg connection pool for database access.
+            contract: Repository contract defining available operations.
+            config: Optional runtime configuration. If None, uses defaults.
+
+        Example:
+            >>> runtime = PostgresRepositoryRuntime(
+            ...     pool=pool,
+            ...     contract=contract,
+            ...     config=ModelRepositoryRuntimeConfig(max_row_limit=100),
+            ... )
+        """
+        self._pool = pool
+        self._contract = contract
+        self._config = config or ModelRepositoryRuntimeConfig()
+
+    @property
+    def contract(self) -> ModelDbRepositoryContract:
+        """Get the repository contract."""
+        return self._contract
+
+    @property
+    def config(self) -> ModelRepositoryRuntimeConfig:
+        """Get the runtime configuration."""
+        return self._config
+
+    async def call(
+        self, op_name: str, *args: object
+    ) -> list[dict[str, object]] | dict[str, object] | None:
+        """Execute a named operation from the contract.
+
+        Validates the operation exists, checks allowed operations,
+        validates argument count, applies determinism and limit
+        constraints, and executes with timeout enforcement.
+
+        Args:
+            op_name: Operation name as defined in contract.ops.
+            *args: Positional arguments matching contract params order.
+
+        Returns:
+            For many=True: list of dicts (possibly empty)
+            For many=False: single dict or None if no row found
+
+        Raises:
+            RepositoryContractError: Operation not found, forbidden mode,
+                or determinism constraint violation (no PK for multi-row).
+            RepositoryValidationError: Argument count mismatch.
+            RepositoryExecutionError: Database execution error.
+            RepositoryTimeoutError: Query exceeded timeout.
+
+        Example:
+            >>> # Single row lookup
+            >>> user = await runtime.call("find_by_id", 123)
+            >>> # Multi-row query
+            >>> users = await runtime.call("find_by_status", "active")
+        """
+        start_time = time.monotonic()
+        context = self._create_error_context(op_name)
+
+        # Lookup operation in contract
+        operation = self._get_operation(op_name, context)
+
+        # Validate operation is allowed
+        self._validate_operation_allowed(operation, op_name, context)
+
+        # Validate argument count
+        self._validate_arg_count(operation, args, op_name, context)
+
+        # Build final SQL with determinism and limit constraints
+        sql = self._build_sql(operation, op_name, context)
+
+        # Execute with timeout
+        try:
+            result = await self._execute_with_timeout(
+                sql, args, operation, op_name, context
+            )
+        except TimeoutError as e:
+            timeout_seconds = self._config.timeout_ms / 1000.0
+            raise RepositoryTimeoutError(
+                f"Query '{op_name}' exceeded timeout of {timeout_seconds}s",
+                op_name=op_name,
+                table=self._get_primary_table(),
+                timeout_seconds=timeout_seconds,
+                sql_fingerprint=self._fingerprint_sql(sql),
+                context=context,
+            ) from e
+
+        # Log metrics if enabled
+        if self._config.emit_metrics:
+            elapsed_ms = (time.monotonic() - start_time) * 1000
+            row_count = (
+                len(result) if isinstance(result, list) else (1 if result else 0)
+            )
+            logger.info(
+                "Repository operation completed",
+                extra={
+                    "op_name": op_name,
+                    "duration_ms": round(elapsed_ms, 2),
+                    "rows_returned": row_count,
+                    "repository": self._contract.name,
+                },
+            )
+
+        return result
+
+    def _create_error_context(self, op_name: str) -> ModelInfraErrorContext:
+        """Create error context for infrastructure errors."""
+        return ModelInfraErrorContext.with_correlation(
+            transport_type=EnumInfraTransportType.DATABASE,
+            operation=f"repository.{op_name}",
+            target_name=self._contract.name,
+        )
+
+    def _get_operation(
+        self, op_name: str, context: ModelInfraErrorContext
+    ) -> ModelDbOperation:
+        """Get operation from contract, raising error if not found."""
+        operation = self._contract.ops.get(op_name)
+        if operation is None:
+            available_ops = list(self._contract.ops.keys())
+            raise RepositoryContractError(
+                f"Unknown operation '{op_name}' not defined in contract '{self._contract.name}'. "
+                f"Available operations: {available_ops}",
+                op_name=op_name,
+                table=self._get_primary_table(),
+                context=context,
+            )
+        return operation
+
+    def _validate_operation_allowed(
+        self,
+        operation: ModelDbOperation,
+        op_name: str,
+        context: ModelInfraErrorContext,
+    ) -> None:
+        """Validate operation mode is allowed by config.
+
+        The contract uses 'read' or 'write' modes (validated by omnibase_core
+        validators at contract load time to ensure SQL verb matching).
+        """
+        mode = operation.mode
+
+        # Check write operations against feature flag
+        if mode == "write" and not self._config.allow_write_operations:
+            raise RepositoryContractError(
+                f"Operation '{op_name}' uses 'write' mode which is disabled. "
+                "Set allow_write_operations=True in config to enable.",
+                op_name=op_name,
+                table=self._get_primary_table(),
+                context=context,
+            )
+
+        # Check mode against allowlist
+        if mode not in self._config.allowed_modes:
+            raise RepositoryContractError(
+                f"Operation mode '{mode}' for '{op_name}' is not in allowed_modes. "
+                f"Allowed: {set(self._config.allowed_modes)}",
+                op_name=op_name,
+                table=self._get_primary_table(),
+                context=context,
+            )
+
+    def _validate_arg_count(
+        self,
+        operation: ModelDbOperation,
+        args: tuple[object, ...],
+        op_name: str,
+        context: ModelInfraErrorContext,
+    ) -> None:
+        """Validate argument count matches contract params.
+
+        Contract params is a dict[str, ModelDbParam] where keys are param names.
+        """
+        param_names = list(operation.params.keys())
+        expected = len(param_names)
+        actual = len(args)
+        if actual != expected:
+            raise RepositoryValidationError(
+                f"Operation '{op_name}' expects {expected} argument(s) ({param_names}), "
+                f"but received {actual}",
+                op_name=op_name,
+                table=self._get_primary_table(),
+                context=context,
+                expected_args=expected,
+                actual_args=actual,
+                param_names=param_names,
+            )
+
+    def _build_sql(
+        self,
+        operation: ModelDbOperation,
+        op_name: str,
+        context: ModelInfraErrorContext,
+    ) -> str:
+        """Build final SQL with determinism and limit constraints.
+
+        Applies ORDER BY injection for multi-row queries without ORDER BY.
+        Applies LIMIT injection or validation based on config.
+
+        Only applies constraints to 'read' mode operations (SELECT).
+        """
+        sql = operation.sql
+        is_read = operation.mode == "read"
+        is_multi_row = operation.returns.many
+
+        # Only apply constraints to read operations
+        if not is_read:
+            return sql
+
+        # Apply determinism constraints for multi-row reads
+        if is_multi_row:
+            sql = self._inject_order_by(sql, op_name, context)
+
+        # Apply limit constraints for multi-row reads
+        if is_multi_row:
+            sql = self._inject_limit(sql, op_name, context)
+
+        return sql
+
+    def _inject_order_by(
+        self,
+        sql: str,
+        op_name: str,
+        context: ModelInfraErrorContext,
+    ) -> str:
+        """Inject ORDER BY clause for deterministic multi-row results.
+
+        Rules:
+            - If ORDER BY exists: no injection needed
+            - If no ORDER BY and PK declared: inject ORDER BY {pk}
+            - If no ORDER BY and no PK: HARD ERROR
+
+        Args:
+            sql: The SQL query to potentially modify.
+            op_name: Operation name for error context.
+            context: Error context for exception raising.
+
+        Returns:
+            SQL with ORDER BY clause (injected or original).
+
+        Raises:
+            RepositoryContractError: No ORDER BY and no primary_key_column.
+        """
+        has_order_by = bool(_ORDER_BY_PATTERN.search(sql))
+        if has_order_by:
+            return sql
+
+        # No ORDER BY - check if we can inject
+        pk_column = self._config.primary_key_column
+        if pk_column is None:
+            raise RepositoryContractError(
+                f"Multi-row query '{op_name}' has no ORDER BY clause and "
+                "primary_key_column is not configured. Deterministic results "
+                "cannot be guaranteed. Either add ORDER BY to the SQL or "
+                "set primary_key_column in config.",
+                op_name=op_name,
+                table=self._get_primary_table(),
+                sql_fingerprint=self._fingerprint_sql(sql),
+                context=context,
+            )
+
+        # Inject ORDER BY using configured order or just PK
+        order_by = self._config.default_order_by or pk_column
+        return f"{sql.rstrip().rstrip(';')} ORDER BY {order_by}"
+
+    def _inject_limit(
+        self,
+        sql: str,
+        op_name: str,
+        context: ModelInfraErrorContext,
+    ) -> str:
+        """Inject or validate LIMIT clause for multi-row results.
+
+        Rules:
+            - If LIMIT > max_row_limit: HARD ERROR
+            - If no LIMIT: inject LIMIT {max_row_limit}
+            - If LIMIT <= max_row_limit: OK (no change)
+
+        Args:
+            sql: The SQL query to potentially modify.
+            op_name: Operation name for error context.
+            context: Error context for exception raising.
+
+        Returns:
+            SQL with LIMIT clause (injected or original).
+
+        Raises:
+            RepositoryContractError: LIMIT exceeds max_row_limit.
+        """
+        max_limit = self._config.max_row_limit
+        limit_match = _LIMIT_PATTERN.search(sql)
+
+        if limit_match:
+            # Existing LIMIT - validate it
+            existing_limit = int(limit_match.group(1))
+            if existing_limit > max_limit:
+                raise RepositoryContractError(
+                    f"Query '{op_name}' has LIMIT {existing_limit} which exceeds "
+                    f"max_row_limit of {max_limit}. Reduce the LIMIT or increase "
+                    "max_row_limit in config.",
+                    op_name=op_name,
+                    table=self._get_primary_table(),
+                    sql_fingerprint=self._fingerprint_sql(sql),
+                    context=context,
+                    existing_limit=existing_limit,
+                    max_row_limit=max_limit,
+                )
+            return sql
+
+        # No LIMIT - inject one
+        return f"{sql.rstrip().rstrip(';')} LIMIT {max_limit}"
+
+    async def _execute_with_timeout(
+        self,
+        sql: str,
+        args: tuple[object, ...],
+        operation: ModelDbOperation,
+        op_name: str,
+        context: ModelInfraErrorContext,
+    ) -> list[dict[str, object]] | dict[str, object] | None:
+        """Execute query with timeout enforcement.
+
+        Uses asyncio.wait_for() to enforce timeout.
+        Uses fetch() for many=True, fetchrow() for many=False.
+
+        Args:
+            sql: Final SQL query to execute.
+            args: Positional arguments for the query.
+            operation: Operation specification.
+            op_name: Operation name for error context.
+            context: Error context for exception raising.
+
+        Returns:
+            Query results as appropriate type.
+
+        Raises:
+            asyncio.TimeoutError: Query exceeded timeout (caught by caller).
+            RepositoryExecutionError: Database execution error.
+        """
+        timeout_seconds = self._config.timeout_ms / 1000.0
+
+        try:
+            async with self._pool.acquire() as conn:
+                if operation.returns.many:
+                    # Multi-row: use fetch()
+                    coro = conn.fetch(sql, *args)
+                    records = await asyncio.wait_for(coro, timeout=timeout_seconds)
+                    return [dict(record) for record in records]
+                else:
+                    # Single-row: use fetchrow()
+                    coro = conn.fetchrow(sql, *args)
+                    record = await asyncio.wait_for(coro, timeout=timeout_seconds)
+                    return dict(record) if record is not None else None
+        except TimeoutError:
+            # Re-raise for caller to handle
+            raise
+        except Exception as e:
+            # Wrap all other exceptions
+            raise RepositoryExecutionError(
+                f"Failed to execute operation '{op_name}': {e}",
+                op_name=op_name,
+                table=self._get_primary_table(),
+                sql_fingerprint=self._fingerprint_sql(sql),
+                context=context,
+            ) from e
+
+    def _get_primary_table(self) -> str | None:
+        """Get the primary table from contract for error context."""
+        return self._contract.tables[0] if self._contract.tables else None
+
+    def _fingerprint_sql(self, sql: str) -> str:
+        """Create a safe fingerprint of SQL for logging/errors.
+
+        Truncates long SQL and removes potentially sensitive values.
+        """
+        # Simple approach: truncate to reasonable length
+        max_len = 200
+        if len(sql) <= max_len:
+            return sql
+        return sql[:max_len] + "..."
+
+
+__all__: list[str] = ["PostgresRepositoryRuntime"]

omnibase_infra/validation/infra_validators.py

@@ -446,7 +446,10 @@ INFRA_NODES_PATH = "src/omnibase_infra/nodes/"
 # - 115 (2026-01-29): OMN-1653 contract registry reducer (+2 unions)
 #                     ContractRegistryEvent: 4-type union for event routing
 #                     contract_yaml: dict | str for flexible YAML handling
-INFRA_MAX_UNIONS = 115
+# - 117 (2026-02-01): OMN-1783 PostgresRepositoryRuntime (+2 unions)
+#                     call() return type: list[dict] | dict | None
+#                     _execute_with_timeout() return type: list[dict] | dict | None
+INFRA_MAX_UNIONS = 117
 
 # Maximum allowed architecture violations in infrastructure code.
 # Set to 0 (strict enforcement) to ensure one-model-per-file principle is always followed.

omnibase_infra/validation/validation_exemptions.yaml

@@ -132,6 +132,24 @@ pattern_exemptions:
       - CLAUDE.md (Accepted Pattern Exceptions - EventBusKafka Complexity)
     ticket: OMN-1305
   # ==========================================================================
+  # PostgresRepositoryRuntime Exemptions (OMN-1783)
+  # ==========================================================================
+  # Contract-driven database runtime with cohesive methods for query execution.
+  # All methods serve the same purpose: executing repository contract operations.
+  # Public: call(), contract (property), config (property)
+  # Private: _create_error_context, _get_operation, _validate_operation_allowed,
+  #          _validate_arg_count, _build_sql, _inject_order_by, _inject_limit,
+  #          _execute_with_timeout, _get_primary_table, _fingerprint_sql
+  - file_pattern: 'postgres_repository_runtime\.py'
+    class_pattern: "Class 'PostgresRepositoryRuntime'"
+    violation_pattern: 'has \d+ methods'
+    reason: >
+      Cohesive runtime class with single responsibility: executing repository contract operations. Methods are logically grouped: validation (3), SQL building (3), execution (1), and helpers (3). Breaking into smaller classes would reduce cohesion and complicate the simple contract-driven execution flow.
+
+    documentation:
+      - OMN-1783 PR description
+    ticket: OMN-1783
+  # ==========================================================================
   # Protocol Plugin Architecture Exemptions
   # ==========================================================================
   # The 'execute' method name is a standard plugin architecture pattern.

{omnibase_infra-0.2.9.dist-info → omnibase_infra-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnibase_infra
-Version: 0.2.9
+Version: 0.3.0
 Summary: ONEX Infrastructure - Service integration and database infrastructure tools
 License: MIT
 License-File: LICENSE
@@ -28,7 +28,7 @@ Requires-Dist: jinja2 (>=3.1.6,<4.0.0)
 Requires-Dist: jsonschema (>=4.20.0,<5.0.0)
 Requires-Dist: mcp (>=1.25.0,<2.0.0)
 Requires-Dist: neo4j (>=5.15.0,<6.0.0)
-Requires-Dist: omnibase-core (>=0.11.0,<0.12.0)
+Requires-Dist: omnibase-core (>=0.12.0,<0.13.0)
 Requires-Dist: omnibase-spi (>=0.6.4,<0.7.0)
 Requires-Dist: opentelemetry-api (>=1.27.0,<2.0.0)
 Requires-Dist: opentelemetry-exporter-otlp (>=1.27.0,<2.0.0)

{omnibase_infra-0.2.9.dist-info → omnibase_infra-0.3.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-omnibase_infra/__init__.py,sha256=EeYAE_QMlLbRX8X_W3kMJh4d7tODmhIA1uGh2w0Rcvg,3853
+omnibase_infra/__init__.py,sha256=GaHfYUvSgKlKfO2_asrsWp0245bbZP91s5O__WZPkHI,3853
 omnibase_infra/adapters/adapter_onex_tool_execution.py,sha256=gKiRTr3pc7-DNAS9_bSmLWssOr1FDCiciwE16cQF3Ro,15377
 omnibase_infra/capabilities/__init__.py,sha256=O6qQjWNwe0ZQt5hpGMMLx4CgagdpxBJzMGVpowi8eKY,462
 omnibase_infra/capabilities/capability_inference_rules.py,sha256=2VDLhvBlDOYyi1eCQGSNB8eXf2JQ4cG9Xftsb3P2xm0,8166
@@ -58,7 +58,7 @@ omnibase_infra/enums/enum_security_rule_id.py,sha256=xMhFMpwC6P9RyCo2DAeR-DFk59m
 omnibase_infra/enums/enum_selection_strategy.py,sha256=lRrJ-s6BpehlifYp4mD2YUcY7X2nEywY2uJ9FFo5EU4,2879
 omnibase_infra/enums/enum_topic_standard.py,sha256=tuPY1Antm3PSeM5L4eLb95U-Uoh4Wi0PTOvgH_h3FEE,1196
 omnibase_infra/enums/enum_validation_severity.py,sha256=Dl6zVgIS13bA-QeNK44YJfVxUzySzbXqGs83HJTCE0M,2858
-omnibase_infra/errors/__init__.py,sha256=zcn-2sukSn2UKsC75jqOWyPZk9yXQ_NB6Daw3AFFhUg,6234
+omnibase_infra/errors/__init__.py,sha256=2-IxVUwNrbnJdYVXDYwBqlkQDHEVG0ry6Y5CkUebQac,6939
 omnibase_infra/errors/error_architecture_violation.py,sha256=2Q6r3pqDifdBiMhZdkdImnwfJIZM_fZP1TyoHZ2aUJA,5849
 omnibase_infra/errors/error_binding_resolution.py,sha256=gZgodKaUaYHJXNpBumcI4IPgkdtIuesowWMb-UWV9Yo,5083
 omnibase_infra/errors/error_chain_propagation.py,sha256=k8A5H7lYvyGiCBqYw2gRHUjlYWMF0NGJu2mtvGQCBoo,6663
@@ -70,6 +70,8 @@ omnibase_infra/errors/error_infra.py,sha256=LizVnhvT9QyRTJu2p-KLpaOQP653XrKNrcM7
 omnibase_infra/errors/error_message_type_registry.py,sha256=2lnv0g51JdjJKNBjxWV1LCsPboApNz9gKBoNUyxZoJY,3566
 omnibase_infra/errors/error_policy_registry.py,sha256=_tOy4OvYEmS0UuntEZZipuYd7UTfEJSbACRVp-9J9Go,4400
 omnibase_infra/errors/error_vault.py,sha256=eS9wa_NWj3iVRFKz8GSkqaYW_O1DYdCQTaDDAyATgls,4686
+omnibase_infra/errors/repository/__init__.py,sha256=Gn4BuBRIr5IgKaUxkOCtMI7GV3UdhbiZhIJ6iA4oJkc,2594
+omnibase_infra/errors/repository/errors_repository.py,sha256=l0chIh-CWm2AUYB8PGPGvn3aaMPxhHS4ltLsCio9QtA,14865
 omnibase_infra/event_bus/__init__.py,sha256=aVcWzLBHWwwEbv5N7m2DQggnkQAjXnnk3_CfbLp_XjE,2410
 omnibase_infra/event_bus/adapters/__init__.py,sha256=FBEFQReRb-Cci-2xXMEer3pFauEOgtIZSXLnK4ByWm4,974
 omnibase_infra/event_bus/adapters/adapter_protocol_event_publisher_kafka.py,sha256=kZ53jGOiPNYuhP_EomHOKDybcoGJ28uBsCGsLDDlGsM,20379
@@ -422,7 +424,7 @@ omnibase_infra/nodes/contract_registry_reducer/models/model_payload_update_heart
 omnibase_infra/nodes/contract_registry_reducer/models/model_payload_update_topic.py,sha256=hIjvOofGdoP77WTVrxrO57lzerlBfqgPpA8Ht_ZpHfE,2316
 omnibase_infra/nodes/contract_registry_reducer/models/model_payload_upsert_contract.py,sha256=d1cFXpCl9TjuMaGfYGIggGka3nfjGtwS7heY8-zW7vg,3587
 omnibase_infra/nodes/contract_registry_reducer/node.py,sha256=hgPBU8LqCsn7USzf5pV8idfiGfNNOekhZkmJvN647iE,4761
-omnibase_infra/nodes/contract_registry_reducer/reducer.py,sha256=H8PD2NncsisljZdFl3MfUExG2rxq2nZaUqbZ8vJpABQ,30654
+omnibase_infra/nodes/contract_registry_reducer/reducer.py,sha256=qAba8_yTAZf3It6ybDTknA-HHZPKbKVr_ThZBu3NTnU,31274
 omnibase_infra/nodes/contract_registry_reducer/registry/__init__.py,sha256=_Stta6Gviw7hTN0LNn_Dr_mpMjkNkfFoHXsS390fVEA,329
 omnibase_infra/nodes/contract_registry_reducer/registry/registry_infra_contract_registry_reducer.py,sha256=zW1EX-I704DNDqmsh4Lz6KFPV_my1ffFWCqPRMilwyE,3617
 omnibase_infra/nodes/effects/README.md,sha256=p0Go_-GuZRnp9MD7u6TX3mF2HcqEQruq4ZQmJNiAsR4,12500
@@ -634,6 +636,10 @@ omnibase_infra/runtime/contract_handler_discovery.py,sha256=1LrZHKkHcpdyaMDXxK3d
 omnibase_infra/runtime/contract_loaders/__init__.py,sha256=Ake8OEryHodK1SxmEBIuqVAH3Uw3ySSsAxqvSaDfRyY,1758
 omnibase_infra/runtime/contract_loaders/handler_routing_loader.py,sha256=bvvZIxjl3mJw9TknRBwPa9ybXXl1J6r7PFkSkdPPLYk,17313
 omnibase_infra/runtime/contract_loaders/operation_bindings_loader.py,sha256=TaOsLzdejsuIH-lZ-oY7eA_U_KMVyIc044oXU26MH6s,29808
+omnibase_infra/runtime/db/__init__.py,sha256=WZLFf7XIXAefkUIiA1sg3Npw120P9zaqK6862mq7wgM,2380
+omnibase_infra/runtime/db/models/__init__.py,sha256=ENQ696584GQHSvbVN85PgEo3Agij5Oo10Vz7-FoVYBE,1377
+omnibase_infra/runtime/db/models/model_repository_runtime_config.py,sha256=4X231FUSe8UywlFIhb4cuyEBk2G0FiJP7-X5-f8Zop0,7826
+omnibase_infra/runtime/db/postgres_repository_runtime.py,sha256=74M8qR6We7DitPwstrFosJiiWXyjBpeVsfn4IXxuo2Q,20297
 omnibase_infra/runtime/dispatch_context_enforcer.py,sha256=44McRbtsqkGTiz7dQTOtV4AmisYOlVKKhI_1n5Jwziw,16620
 omnibase_infra/runtime/emit_daemon/__init__.py,sha256=wnc8rcQCu0vO10y8uqgoEFUsBbYQsJJiKYrJoLgEhsU,3012
 omnibase_infra/runtime/emit_daemon/cli.py,sha256=KP0h3f_cfmNcH-lsVl8rWc-m4Xlhuc0yN5VnNtvNM68,26117
@@ -856,7 +862,7 @@ omnibase_infra/validation/contracts/declarative_node.validation.yaml,sha256=bV2Y
 omnibase_infra/validation/contracts/security.validation.yaml,sha256=NixKgUo7KliQr1yJBY65j2WaxJv_XKoUSCA6pB77DiQ,3858
 omnibase_infra/validation/enums/__init__.py,sha256=J4vRP14R2lHaixXCk1MH5Bzh3Vd0pZmySpN8PkqJc4c,278
 omnibase_infra/validation/enums/enum_contract_violation_severity.py,sha256=beR4vRNXtQ7ckOSOYZHn3NAacZBNTX1csG9_Y6SPd7M,414
-omnibase_infra/validation/infra_validators.py,sha256=5fpBbOgVhzOK8BwCzeOlVDVQoB0tldGAw3vgYCN6hNU,61255
+omnibase_infra/validation/infra_validators.py,sha256=jK7b_6Sby9Fa_YTp93BQOfl1gbPbZnRq2Qjn6bUyOYU,61475
 omnibase_infra/validation/linter_contract.py,sha256=Lv6UkyXx7WFm7Yxwwt8ahXRl-QWfY980Ge7OABUcE5s,33629
 omnibase_infra/validation/mixin_any_type_classification.py,sha256=F1WoGIR_RzZpiHPOVIr-6gOLzD2qWJBnYoqPrLCIiVU,3957
 omnibase_infra/validation/mixin_any_type_exemption.py,sha256=KmKZC8znLuqOuT9vWsUjUF5Lb3aqoI3XgJLXTNNYqIU,23002
@@ -867,7 +873,7 @@ omnibase_infra/validation/models/__init__.py,sha256=p-8vUFXuk-BeJYaWXBbk5DrHq9DZ
 omnibase_infra/validation/models/model_contract_lint_result.py,sha256=Td6OH1VIV7JHPTTZN_iKLM1BQRCtxsjZIMR_DrNau-k,3343
 omnibase_infra/validation/models/model_contract_violation.py,sha256=xRYr-waBuwNVmcHS-ZqoD4g0iLzwtZiibb-Sc4BibaU,1362
 omnibase_infra/validation/service_validation_aggregator.py,sha256=pm7kvtch85hc0ajSKMZ_DPVVsBKZ7JaVYSJsQfpQHr4,14019
-omnibase_infra/validation/validation_exemptions.yaml,sha256=s7aTrP0p7-2ALqBcj7nYmRvFGC-8IA2Q6Si7YJhFaTQ,124328
+omnibase_infra/validation/validation_exemptions.yaml,sha256=wIYYCFfi1NmB6b2lPD3G-Nyt4gO7zv3Wz11z3VsyJtk,125533
 omnibase_infra/validation/validator_any_type.py,sha256=m89Ae6ctmS920yjy6yUvARMcTMVsMnrGby9VlaLRVVw,26285
 omnibase_infra/validation/validator_chain_propagation.py,sha256=JmoYAAH9E0Z_HWh2AGG1WS5zc3lPtq46CjQmmm7IYck,35686
 omnibase_infra/validation/validator_declarative_node.py,sha256=dl8b1eZK9NpzyHZpx5_L_GAnGuaNl3HIRc_IdK1MmYo,31838
@@ -878,8 +884,8 @@ omnibase_infra/validation/validator_routing_coverage.py,sha256=51vYEi5NhU6wqohk2
 omnibase_infra/validation/validator_runtime_shape.py,sha256=9Xl37_dNDinT7nr-BoJ9fG3O5cT1_j6N-C7bojwQi3g,39033
 omnibase_infra/validation/validator_security.py,sha256=Yn_kwxBtPzEj1GzrW0OafL-bR-FgoqdeFzseQqF2_B8,20622
 omnibase_infra/validation/validator_topic_category.py,sha256=1y6STpSNIJsE2AmX5f8PVzPuOfoQmedgocSbEqOdtrM,48798
-omnibase_infra-0.2.9.dist-info/METADATA,sha256=1uOeeZ8daXFsr3VY4HQoXqppGSqNi1hTNA2PjQJMaLU,7554
-omnibase_infra-0.2.9.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-omnibase_infra-0.2.9.dist-info/entry_points.txt,sha256=8jORmczvjPYrahcGRwxtuVqh8KIFOfb04GgnRnQfNsQ,166
-omnibase_infra-0.2.9.dist-info/licenses/LICENSE,sha256=CwYWppeN0neFHYdbbUdHbR4_PiyTYnmk6ufFWuVsL7I,1070
-omnibase_infra-0.2.9.dist-info/RECORD,,
+omnibase_infra-0.3.0.dist-info/METADATA,sha256=0N0aDXnWUfwLdAWoj6ivITqhPj681TUwj9salQS_Ens,7554
+omnibase_infra-0.3.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+omnibase_infra-0.3.0.dist-info/entry_points.txt,sha256=8jORmczvjPYrahcGRwxtuVqh8KIFOfb04GgnRnQfNsQ,166
+omnibase_infra-0.3.0.dist-info/licenses/LICENSE,sha256=CwYWppeN0neFHYdbbUdHbR4_PiyTYnmk6ufFWuVsL7I,1070
+omnibase_infra-0.3.0.dist-info/RECORD,,