Source code for dxaws_accounts.module

from __future__ import annotations

from dataclasses import dataclass
from typing import Any, Optional

from dxaws_core import AwsSession

from .providers.aws import AwsProvider
from .providers.base import ProviderBase

# Import as modules so tests can monkeypatch entrypoints without AWS.
from . import planner
from . import executor




@dataclass(frozen=True)
class ModulePlanResult:
    plan: Any





@dataclass(frozen=True)
class ModuleApplyResult:
    result: Any





class AccountsModule:
    """Public module facade.

    Implements the dxaws declarative convergence flow:

        desired state -> plan -> apply

    Callers construct `Module` with an `AwsSession` (or a provider directly),
    then call `plan()` to compute an idempotent plan, or `apply()` to execute it.
    """

    def __init__(
        self,
        *,
        aws: Optional[AwsSession] = None,
        provider: Optional[ProviderBase] = None,
    ) -> None:
        if provider is None:
            if aws is None:
                raise ValueError("Either 'aws' or 'provider' must be provided")
            provider = AwsProvider(aws=aws)
        self._provider = provider



    def plan(self, *, desired: Any) -> ModulePlanResult:
        p = planner.plan(provider=self._provider, desired=desired)
        return ModulePlanResult(plan=p)




    def apply(self, *, desired: Any) -> ModuleApplyResult:
        p = planner.plan(provider=self._provider, desired=desired)
        r = executor.apply(provider=self._provider, plan=p)
        return ModuleApplyResult(result=r)




# Backwards-compatible alias for callers/tests that prefer a generic name.
Module = AccountsModule