atlan-application-sdk 0.1.1rc24__tar.gz → 0.1.1rc25__tar.gz

atlan_application_sdk-0.1.1rc25/.cursor/BUGBOT.md

@@ -0,0 +1,53 @@
+# Project Review Guidelines - Application SDK
+
+## Core Principles
+
+**Less Code is Better** - Prioritize simplicity, readability, and maintainability over cleverness. Every line of code is a liability that must be justified.
+
+## Critical Review Checklist
+
+### 🔍 Code Quality & Minimalism
+
+- **Necessity Check**: Is this code absolutely necessary? Can existing functionality be reused?
+- **Single Responsibility**: Does each function/class do exactly one thing well?
+- **DRY Violations**: Any repeated logic that should be extracted into shared utilities?
+- **Cognitive Load**: Can a new developer understand this change with less cognitive load?
+- **Magic Numbers/Strings**: All constants properly defined and named in @application_sdk/constants.py
+- **Spell Check**: No typos in code, comments, docstrings, or documentation
+
+### 🏗️ Architecture & Design
+
+- **Module Boundaries**: Changes respect existing module responsibilities
+- **Error Handling**: Proper exception handling with meaningful error messages
+- **Resource Management**: Files, connections, and resources properly closed/released
+- **Async Patterns**: Proper async/await usage where applicable
+- **Configuration**: No hardcoded values; use proper configuration management
+
+### 📝 Documentation Requirements
+
+- **Docstrings**: All public functions, classes, and modules have Google-style docstrings
+- **Type Hints**: All function parameters and return values are typed
+- **Complex Logic**: Non-obvious business logic has inline comments explaining "why"
+
+### 🧪 Testing
+
+- **Testing Standards**: Testing standards are defined in [testing.mdc](mdc:.cursor/rules/testing.mdc)
+- **Test Coverage**: New code has corresponding tests (unit/integration/e2e as appropriate)
+- **Edge Cases**: Error conditions and boundary cases are tested
+- **Mock Strategy**: External dependencies properly mocked/isolated
+- **Test Naming**: Test names clearly describe the scenario being tested
+
+### 🔒 Security & Performance
+
+- **Input Validation**: All external inputs validated and sanitized
+- **Secrets Management**: No secrets in code; proper credential handling
+- **SQL Injection**: Parameterized queries used for all SQL operations
+- **Performance Impact**: Resource-intensive operations benchmarked
+- **Memory Leaks**: Long-running processes properly manage memory
+
+### 📊 Observability & Logging
+
+- **Logging Standards**: logging standards are defined in [logging.mdc](mdc:.cursor/rules/logging.mdc)
+- **Metrics**: Key operations include appropriate metrics
+- **Error Context**: Error logs include sufficient context for debugging
+- **Trace Information**: Critical paths include trace information

atlan_application_sdk-0.1.1rc25/.env.example

@@ -0,0 +1,37 @@
+# refer application_sdk/constants.py for extensive list of environment configurations
+
+ATLAN_WORKFLOW_HOST=localhost
+ATLAN_WORKFLOW_PORT=7233
+ATLAN_WORKFLOW_NAMESPACE=default
+ATLAN_APPLICATION_NAME=default
+ATLAN_TENANT_ID=development
+ATLAN_WORKFLOW_UI_HOST=localhost
+ATLAN_WORKFLOW_UI_PORT=8233
+ATLAN_WORKFLOW_MAX_TIMEOUT_HOURS=1
+ATLAN_MAX_CONCURRENT_ACTIVITIES=5
+ATLAN_APP_DASHBOARD_HOST=localhost
+ATLAN_APP_DASHBOARD_PORT=3000
+ATLAN_APP_HTTP_HOST=0.0.0.0
+ATLAN_APP_HTTP_PORT=8000
+ATLAN_WORKFLOW_METRICS_PORT=8234
+ATLAN_SQL_SERVER_MIN_VERSION=1.0
+ENABLE_OTLP_LOGS=false
+ATLAN_HEARTBEAT_TIMEOUT_SECONDS=120 # 2 minutes
+ATLAN_START_TO_CLOSE_TIMEOUT_SECONDS=7200 # 2 hours
+# ATLAN_ENABLE_OBSERVABILITY_DAPR_SINK="false"
+
+
+# if you plan to deploy the app in customer environment, below is a sample environment variables you need to set
+ATLAN_WORKFLOW_HOST="tenant-temporal.atlan.com"
+ATLAN_WORKFLOW_PORT="443"
+ATLAN_LOCAL_DEVELOPMENT=false
+ATLAN_WORKFLOW_AUTH_ENABLED="true"
+ENABLE_ATLAN_UPLOAD="true"
+ATLAN_DEPLOYMENT_SECRETS='{"appName_app_client_id":"enter_client_id","appName_app_client_secret":"enter_secret","atlan_auth_url":"https://tenant.atlan.com/auth/realms/default/protocol/openid-connect/token","workflow_tls_enabled":"true","deployment_name":"agent-v2"}'
+
+# Storage:
+DEPLOYMENT_OBJECT_STORE_NAME="objectstore"
+UPSTREAM_OBJECT_STORE_NAME="atlan-storage"
+
+# Secret Store
+SECRET_STORE_NAME="aws-secrets"

atlan_application_sdk-0.1.1rc25/.github/release_notes.md

@@ -0,0 +1,7 @@
+## v0.1.1rc25 (August 05, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc24...v0.1.1rc25
+
+### Features
+
+- implement OAuth2 authentication and data transfer for applications (#634) (by @nishantmunjal7 in [e5e70a2](https://github.com/atlanhq/application-sdk/commit/e5e70a2))

{atlan_application_sdk-0.1.1rc24 → atlan_application_sdk-0.1.1rc25}/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## v0.1.1rc25 (August 05, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc24...v0.1.1rc25
+
+### Features
+
+- implement OAuth2 authentication and data transfer for applications (#634) (by @nishantmunjal7 in [e5e70a2](https://github.com/atlanhq/application-sdk/commit/e5e70a2))
+
+
 
 ## v0.1.1rc24 (August 01, 2025)
 

{atlan_application_sdk-0.1.1rc24 → atlan_application_sdk-0.1.1rc25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atlan-application-sdk
-Version: 0.1.1rc24
+Version: 0.1.1rc25
 Summary: Atlan Application SDK is a Python library for developing applications on the Atlan Platform
 Project-URL: Repository, https://github.com/atlanhq/application-sdk
 Project-URL: Documentation, https://github.com/atlanhq/application-sdk/README.md
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.10.0
 Requires-Dist: duckdb-engine>=0.17.0
 Requires-Dist: duckdb>=1.1.3
 Requires-Dist: fastapi[standard]>=0.115.0

{atlan_application_sdk-0.1.1rc24 → atlan_application_sdk-0.1.1rc25}/application_sdk/activities/metadata_extraction/sql.py

@@ -7,14 +7,21 @@ from application_sdk.activities import ActivitiesInterface, ActivitiesState
 from application_sdk.activities.common.models import ActivityStatistics
 from application_sdk.activities.common.utils import auto_heartbeater, get_workflow_id
 from application_sdk.clients.sql import BaseSQLClient
+from application_sdk.common.credential_utils import get_credentials
 from application_sdk.common.dataframe_utils import is_empty_dataframe
+from application_sdk.common.error_codes import ActivityError
 from application_sdk.common.utils import prepare_query, read_sql_files
-from application_sdk.constants import APP_TENANT_ID, APPLICATION_NAME, SQL_QUERIES_PATH
+from application_sdk.constants import (
+    APP_TENANT_ID,
+    APPLICATION_NAME,
+    SQL_QUERIES_PATH,
+    TEMPORARY_PATH,
+)
 from application_sdk.handlers.sql import BaseSQLHandler
 from application_sdk.inputs.parquet import ParquetInput
-from application_sdk.inputs.secretstore import SecretStoreInput
 from application_sdk.inputs.sql_query import SQLQueryInput
 from application_sdk.observability.logger_adaptor import get_logger
+from application_sdk.outputs.atlan_storage import AtlanStorageOutput
 from application_sdk.outputs.json import JsonOutput
 from application_sdk.outputs.parquet import ParquetOutput
 from application_sdk.transformers import TransformerInterface
@@ -137,9 +144,7 @@ class BaseSQLMetadataExtractionActivities(ActivitiesInterface):
         self._state[workflow_id].handler = handler
 
         if "credential_guid" in workflow_args:
-            credentials = await SecretStoreInput.fetch_secret(
-                secret_key=workflow_args["credential_guid"]
-            )
+            credentials = await get_credentials(workflow_args["credential_guid"])
             await sql_client.load(credentials)
 
         self._state[workflow_id].sql_client = sql_client
@@ -485,9 +490,9 @@ class BaseSQLMetadataExtractionActivities(ActivitiesInterface):
         )
         raw_input = raw_input.get_batched_daft_dataframe()
         transformed_output = JsonOutput(
-            output_prefix=output_prefix,
             output_path=output_path,
             output_suffix="transformed",
+            output_prefix=output_prefix,
             typename=typename,
             chunk_start=workflow_args.get("chunk_start"),
         )
@@ -506,3 +511,59 @@ class BaseSQLMetadataExtractionActivities(ActivitiesInterface):
                     )
                 await transformed_output.write_daft_dataframe(transform_metadata)
         return await transformed_output.get_statistics()
+
+    @activity.defn
+    @auto_heartbeater
+    async def upload_to_atlan(
+        self, workflow_args: Dict[str, Any]
+    ) -> ActivityStatistics:
+        """Upload transformed data to Atlan storage.
+
+        This activity uploads the transformed data from object store to Atlan storage
+        (S3 via Dapr). It only runs if ENABLE_ATLAN_UPLOAD is set to true and the
+        Atlan storage component is available.
+
+        Args:
+            workflow_args (Dict[str, Any]): Workflow configuration containing paths and metadata.
+
+        Returns:
+            ActivityStatistics: Upload statistics or skip statistics if upload is disabled.
+
+        Raises:
+            ValueError: If workflow_id or workflow_run_id are missing.
+            ActivityError: If the upload fails with any migration errors when ENABLE_ATLAN_UPLOAD is true.
+        """
+
+        # Upload data from object store to Atlan storage
+        # Use workflow_id/workflow_run_id as the prefix to migrate specific data
+        migration_prefix = os.path.relpath(workflow_args["output_path"], TEMPORARY_PATH)
+        logger.info(
+            f"Starting migration from object store with prefix: {migration_prefix}"
+        )
+        upload_stats = await AtlanStorageOutput.migrate_from_objectstore_to_atlan(
+            prefix=migration_prefix
+        )
+
+        # Log upload statistics
+        logger.info(
+            f"Atlan upload completed: {upload_stats.migrated_files} files uploaded, "
+            f"{upload_stats.failed_migrations} failed"
+        )
+
+        if upload_stats.failures:
+            logger.error(f"Upload failed with {len(upload_stats.failures)} errors")
+            for failure in upload_stats.failures:
+                logger.error(f"Upload error: {failure}")
+
+            # Mark activity as failed when there are upload failures
+            raise ActivityError(
+                f"{ActivityError.ATLAN_UPLOAD_ERROR}: Atlan upload failed with {len(upload_stats.failures)} errors. "
+                f"Failed migrations: {upload_stats.failed_migrations}, "
+                f"Total files: {upload_stats.total_files}"
+            )
+
+        return ActivityStatistics(
+            total_record_count=upload_stats.migrated_files,
+            chunk_count=upload_stats.total_files,
+            typename="atlan-upload-completed",
+        )

{atlan_application_sdk-0.1.1rc24 → atlan_application_sdk-0.1.1rc25}/application_sdk/activities/query_extraction/sql.py

@@ -9,10 +9,11 @@ from temporalio import activity
 from application_sdk.activities import ActivitiesInterface, ActivitiesState
 from application_sdk.activities.common.utils import auto_heartbeater, get_workflow_id
 from application_sdk.clients.sql import BaseSQLClient
+from application_sdk.common.credential_utils import get_credentials
+from application_sdk.constants import UPSTREAM_OBJECT_STORE_NAME
 from application_sdk.handlers import HandlerInterface
 from application_sdk.handlers.sql import BaseSQLHandler
 from application_sdk.inputs.objectstore import ObjectStoreInput
-from application_sdk.inputs.secretstore import SecretStoreInput
 from application_sdk.inputs.sql_query import SQLQueryInput
 from application_sdk.observability.logger_adaptor import get_logger
 from application_sdk.outputs.objectstore import ObjectStoreOutput
@@ -128,9 +129,7 @@ class SQLQueryExtractionActivities(ActivitiesInterface):
         workflow_id = get_workflow_id()
         sql_client = self.sql_client_class()
         if "credential_guid" in workflow_args:
-            credentials = await SecretStoreInput.fetch_secret(
-                secret_key=workflow_args["credential_guid"]
-            )
+            credentials = await get_credentials(workflow_args["credential_guid"])
             await sql_client.load(credentials)
 
         handler = self.handler_class(sql_client)
@@ -414,7 +413,9 @@ class SQLQueryExtractionActivities(ActivitiesInterface):
 
         logger.info(f"Last marker: {last_marker}")
         await ObjectStoreOutput.push_file_to_object_store(
-            workflow_args["output_prefix"], marker_file_path
+            workflow_args["output_prefix"],
+            marker_file_path,
+            object_store_name=UPSTREAM_OBJECT_STORE_NAME,
         )
         logger.info(f"Marker file written to {marker_file_path}")
 
@@ -444,7 +445,9 @@ class SQLQueryExtractionActivities(ActivitiesInterface):
             os.makedirs(workflow_args["output_prefix"], exist_ok=True)
 
             ObjectStoreInput.download_file_from_object_store(
-                workflow_args["output_prefix"], marker_file_path
+                workflow_args["output_prefix"],
+                marker_file_path,
+                object_store_name=UPSTREAM_OBJECT_STORE_NAME,
             )
 
             logger.info(f"Output prefix: {workflow_args['output_prefix']}")

atlan_application_sdk-0.1.1rc25/application_sdk/clients/atlan_auth.py

@@ -0,0 +1,232 @@
+"""OAuth2 token manager with automatic secret store discovery."""
+
+import time
+from typing import Any, Dict, Optional
+
+import aiohttp
+
+from application_sdk.common.error_codes import ClientError
+from application_sdk.constants import (
+    APPLICATION_NAME,
+    WORKFLOW_AUTH_CLIENT_ID_KEY,
+    WORKFLOW_AUTH_CLIENT_SECRET_KEY,
+    WORKFLOW_AUTH_ENABLED,
+    WORKFLOW_AUTH_URL_KEY,
+)
+from application_sdk.inputs.secretstore import SecretStoreInput
+from application_sdk.observability.logger_adaptor import get_logger
+
+logger = get_logger(__name__)
+
+
+class AtlanAuthClient:
+    """OAuth2 token manager for cloud service authentication.
+
+    Currently supports Temporal authentication. Future versions will support:
+    - Centralized token caching
+    - Handling EventIngress authentication
+    - Invoking more services with the same token
+
+    The same token (with appropriate scopes) can be used for multiple services
+    that the application needs to access.
+    """
+
+    def __init__(self):
+        """Initialize the OAuth2 token manager.
+
+        Credentials are always fetched from the configured Dapr secret store component.
+        The secret store component can be configured to use various backends
+        (environment variables, AWS Secrets Manager, Azure Key Vault, etc.)
+        """
+        self.application_name = APPLICATION_NAME
+        self.auth_config: Dict[str, Any] = SecretStoreInput.get_deployment_secret()
+        self.auth_enabled: bool = WORKFLOW_AUTH_ENABLED
+        self.auth_url: Optional[str] = None
+
+        # Secret store credentials (cached after first fetch)
+        self.credentials: Optional[Dict[str, str]] = None
+
+        # Token data
+        self._access_token: Optional[str] = None
+        self._token_expiry: float = 0
+
+    async def get_access_token(self, force_refresh: bool = False) -> Optional[str]:
+        """Get a valid access token, refreshing if necessary.
+
+        The token contains all scopes configured for this application in the OAuth2 provider
+        and can be used for multiple services (Temporal, Data transfer, etc.).
+
+        Args:
+            force_refresh: If True, forces token refresh regardless of expiry
+
+        Returns:
+            Optional[str]: A valid access token, or None if authentication is disabled
+
+        Raises:
+            ValueError: If authentication is disabled or credentials are missing
+            AtlanAuthError: If token refresh fails
+        """
+
+        if not self.auth_enabled:
+            return None
+
+        # Get credentials and ensure auth_url is set
+        if not self.credentials:
+            self.credentials = await self._extract_auth_credentials()
+            if not self.credentials:
+                raise ClientError(
+                    f"{ClientError.AUTH_CREDENTIALS_ERROR}: OAuth2 credentials not found for application '{self.application_name}'. "
+                )
+
+        if not self.auth_url:
+            raise ClientError(
+                f"{ClientError.AUTH_CONFIG_ERROR}: Auth URL is required when auth is enabled"
+            )
+
+        # Return existing token if it's still valid (with 30s buffer) and not forcing refresh
+        current_time = time.time()
+        if (
+            not force_refresh
+            and self._access_token
+            and current_time < self._token_expiry - 30
+        ):
+            return self._access_token
+
+        # Refresh token
+        logger.info("Refreshing OAuth2 token")
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                self.auth_url,
+                data={
+                    "grant_type": "client_credentials",
+                    "client_id": self.credentials["client_id"],
+                    "client_secret": self.credentials["client_secret"],
+                },
+                headers={"Content-Type": "application/x-www-form-urlencoded"},
+            ) as response:
+                if not response.ok:
+                    # Clear cached credentials and token on auth failure in case they're stale
+                    self.clear_cache()
+                    error_text = await response.text()
+                    raise ClientError(
+                        f"{ClientError.AUTH_TOKEN_REFRESH_ERROR}: Failed to refresh token (HTTP {response.status}): {error_text}"
+                    )
+
+                token_data = await response.json()
+
+                # Validate required fields exist
+                if "access_token" not in token_data or "expires_in" not in token_data:
+                    raise ClientError(
+                        f"{ClientError.AUTH_TOKEN_REFRESH_ERROR}: Missing required fields in OAuth2 response"
+                    )
+
+                self._access_token = token_data["access_token"]
+                self._token_expiry = current_time + token_data["expires_in"]
+
+                if self._access_token is None:
+                    raise ClientError(
+                        f"{ClientError.AUTH_TOKEN_REFRESH_ERROR}: Received null access token from server"
+                    )
+                return self._access_token
+
+    async def get_authenticated_headers(self) -> Dict[str, str]:
+        """Get authentication headers for HTTP requests.
+
+        This method returns headers that can be used for any HTTP request
+        to services that this application is authorized to access.
+
+        Returns:
+            Dict[str, str]: Headers dictionary with Authorization header
+
+        Examples:
+            >>> auth_client = AtlanAuthClient("user-management")
+            >>> headers = await auth_client.get_authenticated_headers()
+            >>> # Use headers for any HTTP request
+            >>> async with aiohttp.ClientSession() as session:
+            ...     await session.get("https://api.company.com/users", headers=headers)
+        """
+        if not self.auth_enabled:
+            return {}
+
+        token = await self.get_access_token()
+        if token is None:
+            return {}
+        return {"Authorization": f"Bearer {token}"}
+
+    def get_token_expiry_time(self) -> Optional[float]:
+        """Get the expiry time of the current token.
+
+        Returns:
+            Optional[float]: Unix timestamp of token expiry, or None if no token
+        """
+        return self._token_expiry if self._access_token else None
+
+    def get_time_until_expiry(self) -> Optional[float]:
+        """Get the time remaining until token expires.
+
+        Returns:
+            Optional[float]: Seconds until expiry, or None if no token
+        """
+        if not self._access_token or not self._token_expiry:
+            return None
+
+        return max(0, self._token_expiry - time.time())
+
+    async def _extract_auth_credentials(self) -> Optional[Dict[str, str]]:
+        """Fetch app credentials from secret store - auth-specific logic"""
+        if (
+            WORKFLOW_AUTH_CLIENT_ID_KEY in self.auth_config
+            and WORKFLOW_AUTH_CLIENT_SECRET_KEY in self.auth_config
+        ):
+            credentials = {
+                "client_id": self.auth_config[WORKFLOW_AUTH_CLIENT_ID_KEY],
+                "client_secret": self.auth_config[WORKFLOW_AUTH_CLIENT_SECRET_KEY],
+            }
+
+            if WORKFLOW_AUTH_URL_KEY in self.auth_config:
+                self.auth_url = self.auth_config[WORKFLOW_AUTH_URL_KEY]
+
+            return credentials
+        return None
+
+    def clear_cache(self) -> None:
+        """Clear cached credentials and token.
+
+        This method clears all cached authentication data, forcing fresh
+        credential discovery and token refresh on next access.
+        Useful for credential rotation scenarios.
+        """
+        # we are doing this to force a fetch of the credentials from secret store
+        self.credentials = None
+        self.auth_url = None
+        self._access_token = None
+        self._token_expiry = 0
+        self.auth_config = {}
+
+    def calculate_refresh_interval(self) -> int:
+        """Calculate the optimal token refresh interval based on token expiry.
+
+        Returns:
+            int: Refresh interval in seconds
+        """
+        # Try to get token expiry time
+        expiry_time = self.get_token_expiry_time()
+        if expiry_time:
+            # Calculate time until expiry
+            time_until_expiry = self.get_time_until_expiry()
+            if time_until_expiry and time_until_expiry > 0:
+                # Refresh at 80% of the token lifetime, but at least every 5 minutes
+                # and at most every 30 minutes
+                refresh_interval = max(
+                    5 * 60,  # Minimum 5 minutes
+                    min(
+                        30 * 60,  # Maximum 30 minutes
+                        int(time_until_expiry * 0.8),  # 80% of token lifetime
+                    ),
+                )
+                return refresh_interval
+
+        # Default fallback: refresh every 14 minutes
+        logger.info("Using default token refresh interval: 14 minutes")
+        return 14 * 60

{atlan_application_sdk-0.1.1rc24 → atlan_application_sdk-0.1.1rc25}/application_sdk/clients/sql.py

@@ -18,7 +18,6 @@ from application_sdk.common.aws_utils import (
     generate_aws_rds_token_with_iam_role,
     generate_aws_rds_token_with_iam_user,
 )
-from application_sdk.common.credential_utils import resolve_credentials
 from application_sdk.common.error_codes import ClientError, CommonError
 from application_sdk.common.utils import parse_credentials_extra
 from application_sdk.constants import AWS_SESSION_NAME, USE_SERVER_SIDE_CURSOR
@@ -69,7 +68,6 @@ class BaseSQLClient(ClientInterface):
         """
         self.use_server_side_cursor = use_server_side_cursor
         self.credentials = credentials
-        self.resolved_credentials = {}
         self.sql_alchemy_connect_args = sql_alchemy_connect_args
 
     async def load(self, credentials: Dict[str, Any]) -> None:
@@ -82,7 +80,6 @@ class BaseSQLClient(ClientInterface):
             ClientError: If connection fails due to authentication or connection issues
         """
         self.credentials = credentials  # Update the instance credentials
-        self.resolved_credentials = await resolve_credentials(credentials)
         try:
             from sqlalchemy import create_engine
 
@@ -119,10 +116,10 @@ class BaseSQLClient(ClientInterface):
         Raises:
             CommonError: If required credentials (username or database) are missing.
         """
-        extra = parse_credentials_extra(self.resolved_credentials)
-        aws_access_key_id = self.resolved_credentials.get("username")
-        aws_secret_access_key = self.resolved_credentials.get("password")
-        host = self.resolved_credentials.get("host")
+        extra = parse_credentials_extra(self.credentials)
+        aws_access_key_id = self.credentials.get("username")
+        aws_secret_access_key = self.credentials.get("password")
+        host = self.credentials.get("host")
         user = extra.get("username")
         database = extra.get("database")
         if not user:
@@ -134,8 +131,8 @@ class BaseSQLClient(ClientInterface):
                 f"{CommonError.CREDENTIALS_PARSE_ERROR}: database is required for IAM user authentication"
             )
 
-        port = self.resolved_credentials.get("port")
-        region = self.resolved_credentials.get("region")
+        port = self.credentials.get("port")
+        region = self.credentials.get("region")
         token = generate_aws_rds_token_with_iam_user(
             aws_access_key_id=aws_access_key_id,
             aws_secret_access_key=aws_secret_access_key,
@@ -160,7 +157,7 @@ class BaseSQLClient(ClientInterface):
         Raises:
             CommonError: If required credentials (aws_role_arn or database) are missing.
         """
-        extra = parse_credentials_extra(self.resolved_credentials)
+        extra = parse_credentials_extra(self.credentials)
         aws_role_arn = extra.get("aws_role_arn")
         database = extra.get("database")
         external_id = extra.get("aws_external_id")
@@ -175,10 +172,10 @@ class BaseSQLClient(ClientInterface):
             )
 
         session_name = AWS_SESSION_NAME
-        username = self.resolved_credentials.get("username")
-        host = self.resolved_credentials.get("host")
-        port = self.resolved_credentials.get("port")
-        region = self.resolved_credentials.get("region")
+        username = self.credentials.get("username")
+        host = self.credentials.get("host")
+        port = self.credentials.get("port")
+        region = self.credentials.get("region")
 
         token = generate_aws_rds_token_with_iam_role(
             role_arn=aws_role_arn,
@@ -204,9 +201,7 @@ class BaseSQLClient(ClientInterface):
         Raises:
             CommonError: If an invalid authentication type is specified.
         """
-        authType = self.resolved_credentials.get(
-            "authType", "basic"
-        )  # Default to basic auth
+        authType = self.credentials.get("authType", "basic")  # Default to basic auth
         token = None
 
         match authType:
@@ -215,7 +210,7 @@ class BaseSQLClient(ClientInterface):
             case "iam_role":
                 token = self.get_iam_role_token()
             case "basic":
-                token = self.resolved_credentials.get("password")
+                token = self.credentials.get("password")
             case _:
                 raise CommonError(f"{CommonError.CREDENTIALS_PARSE_ERROR}: {authType}")
 
@@ -273,7 +268,7 @@ class BaseSQLClient(ClientInterface):
         Raises:
             ValueError: If required connection parameters are missing.
         """
-        extra = parse_credentials_extra(self.resolved_credentials)
+        extra = parse_credentials_extra(self.credentials)
 
         # TODO: Uncomment this when the native deployment is ready
         # If the compiled_url is present, use it directly
@@ -289,7 +284,7 @@ class BaseSQLClient(ClientInterface):
             if param == "password":
                 param_values[param] = auth_token
             else:
-                value = self.resolved_credentials.get(param) or extra.get(param)
+                value = self.credentials.get(param) or extra.get(param)
                 if value is None:
                     raise ValueError(f"{param} is required")
                 param_values[param] = value
@@ -304,7 +299,7 @@ class BaseSQLClient(ClientInterface):
         if self.DB_CONFIG.get("parameters"):
             parameter_keys = self.DB_CONFIG["parameters"]
             self.DB_CONFIG["parameters"] = {
-                key: self.resolved_credentials.get(key) or extra.get(key)
+                key: self.credentials.get(key) or extra.get(key)
                 for key in parameter_keys
             }
             conn_str = self.add_connection_params(
@@ -404,8 +399,6 @@ class AsyncBaseSQLClient(BaseSQLClient):
             ValueError: If connection fails due to invalid credentials or connection issues.
         """
         self.credentials = credentials
-        self.resolved_credentials = await resolve_credentials(credentials)
-
         try:
             from sqlalchemy.ext.asyncio import create_async_engine