snowflake-cli 3.10.1__py3-none-any.whl → 3.12.0__py3-none-any.whl

snowflake/cli/_app/snow_connector.py

@@ -22,11 +22,16 @@ from typing import Dict, Optional
 import snowflake.connector
 from click.exceptions import ClickException
 from snowflake.cli import __about__
+from snowflake.cli._app.auth.oidc_providers import OidcProviderTypeWithAuto
 from snowflake.cli._app.constants import (
+    AUTHENTICATOR_WORKLOAD_IDENTITY,
     INTERNAL_APPLICATION_NAME,
     PARAM_APPLICATION_NAME,
 )
 from snowflake.cli._app.telemetry import command_info
+from snowflake.cli._plugins.auth.oidc.manager import (
+    OidcManager,
+)
 from snowflake.cli.api.config import (
     get_connection_dict,
     get_env_value,
@@ -40,6 +45,7 @@ from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.secret import SecretType
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.connector import SnowflakeConnection
+from snowflake.connector.auth.workload_identity import ApiFederatedAuthenticationType
 from snowflake.connector.errors import DatabaseError, ForbiddenError
 
 log = logging.getLogger(__name__)
@@ -54,6 +60,7 @@ SUPPORTED_ENV_OVERRIDES = [
     "user",
     "password",
     "authenticator",
+    "workload_identity_provider",
     "private_key_file",
     "private_key_path",
     "private_key_raw",
@@ -153,6 +160,14 @@ def connect_to_snowflake(
     if connection_parameters.get("authenticator") == "username_password_mfa":
         connection_parameters["client_request_mfa_token"] = True
 
+    # Handle WORKLOAD_IDENTITY authenticator (OIDC authentication)
+    if (
+        connection_parameters.get("authenticator") == AUTHENTICATOR_WORKLOAD_IDENTITY
+        and connection_parameters.get("workload_identity_provider")
+        == ApiFederatedAuthenticationType.OIDC.value
+    ):
+        _maybe_update_oidc_token(connection_parameters)
+
     if enable_diag:
         connection_parameters["enable_connection_diag"] = enable_diag
         if diag_log_path:
@@ -335,3 +350,23 @@ def prepare_private_key(
             encryption_algorithm=NoEncryption(),
         )
     )
+
+
+def _maybe_update_oidc_token(connection_parameters: dict) -> dict:
+    """Try to obtain OIDC token automatically."""
+    try:
+        manager = OidcManager()
+        if token := manager.read_token(OidcProviderTypeWithAuto.AUTO):
+            log.info("%s token acquired automatically", AUTHENTICATOR_WORKLOAD_IDENTITY)
+            connection_parameters.update(
+                {
+                    "token": token,
+                }
+            )
+    except Exception as e:
+        log.info(
+            "No token found when while %s auto auto-detection: %s",
+            AUTHENTICATOR_WORKLOAD_IDENTITY,
+            str(e),
+        )
+    return connection_parameters

snowflake/cli/_plugins/auth/__init__.py

@@ -1,11 +1,13 @@
 from snowflake.cli._plugins.auth.keypair.commands import app as keypair_app
+from snowflake.cli._plugins.auth.oidc.commands import (
+    app as oidc_app,
+)
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
-from snowflake.cli.api.feature_flags import FeatureFlag
 
 app = SnowTyperFactory(
     name="auth",
     help="Manages authentication methods.",
-    is_hidden=lambda: FeatureFlag.ENABLE_AUTH_KEYPAIR.is_disabled(),
 )
 
 app.add_typer(keypair_app)
+app.add_typer(oidc_app)

snowflake/cli/_plugins/auth/keypair/commands.py

@@ -4,6 +4,7 @@ import typer
 from snowflake.cli._plugins.auth.keypair.manager import AuthManager, PublicKeyProperty
 from snowflake.cli.api.commands.flags import SecretTypeParser
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.output.types import (
     CollectionResult,
     CommandResult,
@@ -16,6 +17,7 @@ from snowflake.cli.api.secure_path import SecurePath
 app = SnowTyperFactory(
     name="keypair",
     help="Manages authentication.",
+    is_hidden=lambda: FeatureFlag.ENABLE_AUTH_KEYPAIR.is_disabled(),
 )
 
 

snowflake/cli/_plugins/auth/oidc/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2024 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

snowflake/cli/_plugins/auth/oidc/commands.py

@@ -0,0 +1,47 @@
+# Copyright (c) 2024 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typer
+from snowflake.cli._app.auth.oidc_providers import (
+    OidcProviderTypeWithAuto,
+)
+from snowflake.cli._plugins.auth.oidc.manager import OidcManager
+from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.output.types import MessageResult
+
+app = SnowTyperFactory(
+    name="oidc",
+    help="Manages OIDC authentication.",
+)
+
+
+AutoProviderTypeOption = typer.Option(
+    OidcProviderTypeWithAuto.AUTO.value,
+    "--type",
+    help=f"Type of OIDC provider to use",
+    show_default=False,
+)
+
+
+@app.command("read-token", requires_connection=False)
+def read_token(
+    _type: OidcProviderTypeWithAuto = AutoProviderTypeOption,
+    **options,
+):
+    """
+    Reads OIDC token based on the specified type.
+    Use 'auto' to auto-detect available providers.
+    """
+    result = OidcManager().read_token(provider_type=_type)
+    return MessageResult(result)

snowflake/cli/_plugins/auth/oidc/manager.py

@@ -0,0 +1,66 @@
+# Copyright (c) 2024 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+from typing import TypeAlias
+
+from snowflake.cli._app.auth.errors import OidcProviderError
+from snowflake.cli._app.auth.oidc_providers import (
+    OidcProviderType,
+    OidcProviderTypeWithAuto,
+    auto_detect_oidc_provider,
+    get_active_oidc_provider,
+)
+from snowflake.cli.api.exceptions import CliError
+
+logger = logging.getLogger(__name__)
+
+
+Providers: TypeAlias = OidcProviderType | OidcProviderTypeWithAuto
+
+
+class OidcManager:
+    """
+    Manages OIDC authentication.
+
+    This class provides methods to read OIDC configurations for authentication.
+    """
+
+    def read_token(
+        self,
+        provider_type: Providers = OidcProviderTypeWithAuto.AUTO,
+    ) -> str:
+        """
+        Reads OIDC token based on the specified provider type.
+
+        Args:
+            provider_type: Type of provider to read token from ("auto" for auto-detection)
+
+        Returns:
+            Token string or provider information
+
+        Raises:
+            CliError: If token reading fails
+        """
+        logger.info("Reading OIDC token with provider type: %s", provider_type)
+
+        try:
+            if provider_type == OidcProviderTypeWithAuto.AUTO:
+                provider = auto_detect_oidc_provider()
+            else:
+                provider = get_active_oidc_provider(provider_type.value)
+            return provider.get_token()
+        except OidcProviderError as e:
+            logger.error("OIDC provider error: %s", str(e))
+            raise CliError(str(e))

snowflake/cli/_plugins/auth/oidc/plugin_spec.py

@@ -0,0 +1,30 @@
+# Copyright (c) 2024 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from snowflake.cli._plugins.auth import app
+from snowflake.cli.api.plugins.command import (
+    SNOWCLI_ROOT_COMMAND_PATH,
+    CommandSpec,
+    CommandType,
+    plugin_hook_impl,
+)
+
+
+@plugin_hook_impl
+def command_spec():
+    return CommandSpec(
+        parent_command_path=SNOWCLI_ROOT_COMMAND_PATH,
+        command_type=CommandType.COMMAND_GROUP,
+        typer_instance=app.create_instance(),
+    )

snowflake/cli/_plugins/connection/commands.py

@@ -53,6 +53,7 @@ from snowflake.cli.api.commands.flags import (
     TokenFilePathOption,
     UserOption,
     WarehouseOption,
+    WorkloadIdentityProviderOption,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.config import (
@@ -62,7 +63,9 @@ from snowflake.cli.api.config import (
     get_all_connections,
     get_connection_dict,
     get_default_connection_name,
+    remove_connection_from_proper_file,
     set_config_value,
+    unset_config_value,
 )
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import ObjectType
@@ -220,6 +223,12 @@ def add(
         *AuthenticatorOption.param_decls,
         help="Chosen authenticator, if other than password-based",
     ),
+    workload_identity_provider: Optional[str] = typer.Option(
+        None,
+        "-W",
+        *WorkloadIdentityProviderOption.param_decls,
+        help="Workload identity provider type",
+    ),
     private_key_file: Optional[str] = typer.Option(
         None,
         "--private-key",
@@ -256,6 +265,7 @@ def add(
         "port": port,
         "region": region,
         "authenticator": authenticator,
+        "workload_identity_provider": workload_identity_provider,
         "private_key_file": private_key_file,
         "token_file_path": token_file_path,
     }
@@ -317,6 +327,30 @@ def add(
     )
 
 
+@app.command(requires_connection=False)
+def remove(
+    connection_name: str = typer.Argument(
+        help="Name of the connection to remove.",
+        show_default=False,
+    ),
+    **options,
+):
+    """Removes a connection from configuration file."""
+    if not connection_exists(connection_name):
+        raise UsageError(f"Connection {connection_name} does not exist.")
+
+    is_default = get_default_connection_name() == connection_name
+    if is_default:
+        unset_config_value(path=["default_connection_name"])
+
+    connections_file = remove_connection_from_proper_file(connection_name)
+
+    return MessageResult(
+        f"Removed connection {connection_name} from {connections_file}."
+        f"{' It was the default connection, so default connection is now unset.' if is_default else ''}"
+    )
+
+
 @app.command(requires_connection=True)
 def test(
     **options,
@@ -355,9 +389,9 @@ def test(
         "Host": conn.host,
         "Account": conn.account,
         "User": conn.user,
-        "Role": f'{conn.role or "not set"}',
-        "Database": f'{conn.database or "not set"}',
-        "Warehouse": f'{conn.warehouse or "not set"}',
+        "Role": f"{conn.role or 'not set'}",
+        "Database": f"{conn.database or 'not set'}",
+        "Warehouse": f"{conn.warehouse or 'not set'}",
     }
 
     if conn_ctx.enable_diag:

snowflake/cli/_plugins/dbt/commands.py

@@ -19,7 +19,6 @@ from typing import Optional
 
 import typer
 from click import types
-from rich.progress import Progress, SpinnerColumn, TextColumn
 from snowflake.cli._plugins.dbt.constants import (
     DBT_COMMANDS,
     OUTPUT_COLUMN_NAME,
@@ -31,7 +30,9 @@ from snowflake.cli._plugins.object.command_aliases import add_object_command_ali
 from snowflake.cli._plugins.object.commands import scope_option
 from snowflake.cli.api.commands.decorators import global_options_with_connection
 from snowflake.cli.api.commands.flags import identifier_argument, like_option
+from snowflake.cli.api.commands.overrideable_parameter import OverrideableOption
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.console.console import cli_console
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.feature_flags import FeatureFlag
@@ -59,6 +60,16 @@ DBTNameArgument = identifier_argument(sf_object="DBT Project", example="my_pipel
 DBTNameOrCommandArgument = identifier_argument(
     sf_object="DBT Project", example="my_pipeline", click_type=types.StringParamType()
 )
+DefaultTargetOption = OverrideableOption(
+    None,
+    "--default-target",
+    mutually_exclusive=["unset_default_target"],
+)
+UnsetDefaultTargetOption = OverrideableOption(
+    False,
+    "--unset-default-target",
+    mutually_exclusive=["default_target"],
+)
 
 add_object_command_aliases(
     app=app,
@@ -92,6 +103,21 @@ def deploy_dbt(
         False,
         help="Overwrites conflicting files in the project, if any.",
     ),
+    default_target: Optional[str] = DefaultTargetOption(
+        help="Default target for the dbt project. Mutually exclusive with --unset-default-target.",
+        hidden=FeatureFlag.ENABLE_DBT_GA_FEATURES.is_disabled(),
+    ),
+    unset_default_target: Optional[bool] = UnsetDefaultTargetOption(
+        help="Unset the default target for the dbt project. Mutually exclusive with --default-target.",
+        hidden=FeatureFlag.ENABLE_DBT_GA_FEATURES.is_disabled(),
+    ),
+    external_access_integrations: Optional[list[str]] = typer.Option(
+        None,
+        "--external-access-integration",
+        show_default=False,
+        help="External access integration to be used by the dbt object.",
+        hidden=FeatureFlag.ENABLE_DBT_GA_FEATURES.is_disabled(),
+    ),
     **options,
 ) -> CommandResult:
     """
@@ -99,6 +125,11 @@ def deploy_dbt(
     provided; or create a new one if it doesn't exist; or update files and
     create a new version if it exists.
     """
+    if FeatureFlag.ENABLE_DBT_GA_FEATURES.is_disabled():
+        default_target = None
+        unset_default_target = False
+        external_access_integrations = None
+
     project_path = SecurePath(source) if source is not None else SecurePath.cwd()
     profiles_dir_path = SecurePath(profiles_dir) if profiles_dir else project_path
     return QueryResult(
@@ -107,6 +138,9 @@ def deploy_dbt(
             project_path.resolve(),
             profiles_dir_path.resolve(),
             force=force,
+            default_target=default_target,
+            unset_default_target=unset_default_target,
+            external_access_integrations=external_access_integrations,
         )
     )
 
@@ -161,13 +195,8 @@ for cmd in DBT_COMMANDS:
                 f"Command submitted. You can check the result with `snow sql -q \"select execution_status from table(information_schema.query_history_by_user()) where query_id in ('{result.sfqid}');\"`"
             )
 
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            transient=True,
-        ) as progress:
-            progress.add_task(description=f"Executing 'dbt {dbt_command}'", total=None)
-
+        with cli_console.spinner() as spinner:
+            spinner.add_task(description=f"Executing 'dbt {dbt_command}'", total=None)
             result = dbt_manager.execute(*execute_args)
 
             try:

snowflake/cli/_plugins/dbt/manager.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 from collections import defaultdict
 from pathlib import Path
 from tempfile import TemporaryDirectory
+from typing import List, Optional, TypedDict
 
 import yaml
 from snowflake.cli._plugins.dbt.constants import PROFILES_FILENAME
@@ -26,10 +27,14 @@ from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB, ObjectType
 from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.project.util import unquote_identifier
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector.cursor import SnowflakeCursor
+from snowflake.connector.errors import ProgrammingError
+
+
+class DBTObjectEditableAttributes(TypedDict):
+    default_target: Optional[str]
 
 
 class DBTManager(SqlExecutionMixin):
@@ -43,12 +48,44 @@ class DBTManager(SqlExecutionMixin):
             object_type=ObjectType.DBT_PROJECT.value.cli_name, fqn=name
         )
 
+    @staticmethod
+    def describe(name: FQN) -> SnowflakeCursor:
+        return ObjectManager().describe(
+            object_type=ObjectType.DBT_PROJECT.value.cli_name, fqn=name
+        )
+
+    @staticmethod
+    def get_dbt_object_attributes(name: FQN) -> Optional[DBTObjectEditableAttributes]:
+        """Get editable attributes of an existing DBT project, or None if it doesn't exist."""
+        try:
+            cursor = DBTManager().describe(name)
+        except ProgrammingError as exc:
+            if "DBT PROJECT" in exc.msg and "does not exist" in exc.msg:
+                return None
+            raise exc
+
+        rows = list(cursor)
+        if not rows:
+            return None
+
+        row = rows[0]
+        # Convert row to dict using column names
+        columns = [desc[0] for desc in cursor.description]
+        row_dict = dict(zip(columns, row))
+
+        return DBTObjectEditableAttributes(
+            default_target=row_dict.get("default_target")
+        )
+
     def deploy(
         self,
         fqn: FQN,
         path: SecurePath,
         profiles_path: SecurePath,
         force: bool,
+        default_target: Optional[str] = None,
+        unset_default_target: bool = False,
+        external_access_integrations: Optional[List[str]] = None,
     ) -> SnowflakeCursor:
         dbt_project_path = path / "dbt_project.yml"
         if not dbt_project_path.exists():
@@ -63,14 +100,13 @@ class DBTManager(SqlExecutionMixin):
             except KeyError:
                 raise CliError("`profile` is not defined in dbt_project.yml")
 
-        self._validate_profiles(profiles_path, profile)
+        self._validate_profiles(profiles_path, profile, default_target)
 
         with cli_console.phase("Creating temporary stage"):
             stage_manager = StageManager()
-            unquoted_name = unquote_identifier(fqn.name)
-            stage_fqn = FQN.from_string(f"DBT_{unquoted_name}_STAGE").using_context()
-            stage_name = stage_manager.get_standard_stage_prefix(stage_fqn)
+            stage_fqn = FQN.from_resource(ObjectType.DBT_PROJECT, fqn, "STAGE")
             stage_manager.create(stage_fqn, temporary=True)
+            stage_name = stage_manager.get_standard_stage_prefix(stage_fqn)
 
         with cli_console.phase("Copying project files to stage"):
             with TemporaryDirectory() as tmp:
@@ -88,22 +124,109 @@ class DBTManager(SqlExecutionMixin):
 
         with cli_console.phase("Creating DBT project"):
             if force is True:
-                query = f"CREATE OR REPLACE DBT PROJECT {fqn}"
-            elif self.exists(name=fqn):
-                query = f"ALTER DBT PROJECT {fqn} ADD VERSION"
+                return self._deploy_create_or_replace(
+                    fqn, stage_name, default_target, external_access_integrations
+                )
             else:
-                query = f"CREATE DBT PROJECT {fqn}"
-            query += f"\nFROM {stage_name}"
-            return self.execute_query(query)
+                dbt_object_attributes = self.get_dbt_object_attributes(fqn)
+                if dbt_object_attributes is not None:
+                    return self._deploy_alter(
+                        fqn,
+                        stage_name,
+                        dbt_object_attributes,
+                        default_target,
+                        unset_default_target,
+                        external_access_integrations,
+                    )
+                else:
+                    return self._deploy_create(
+                        fqn, stage_name, default_target, external_access_integrations
+                    )
+
+    def _deploy_alter(
+        self,
+        fqn: FQN,
+        stage_name: str,
+        dbt_object_attributes: DBTObjectEditableAttributes,
+        default_target: Optional[str],
+        unset_default_target: bool,
+        external_access_integrations: Optional[List[str]],
+    ) -> SnowflakeCursor:
+        query = f"ALTER DBT PROJECT {fqn} ADD VERSION"
+        query += f"\nFROM {stage_name}"
+        query = self._handle_external_access_integrations_query(
+            query, external_access_integrations
+        )
+        result = self.execute_query(query)
+        current_default_target = dbt_object_attributes.get("default_target")
+        if unset_default_target and current_default_target is not None:
+            unset_query = f"ALTER DBT PROJECT {fqn} UNSET DEFAULT_TARGET"
+            self.execute_query(unset_query)
+        elif default_target and (
+            current_default_target is None
+            or current_default_target.lower() != default_target.lower()
+        ):
+            set_default_query = (
+                f"ALTER DBT PROJECT {fqn} SET DEFAULT_TARGET='{default_target}'"
+            )
+            self.execute_query(set_default_query)
+        return result
+
+    def _deploy_create(
+        self,
+        fqn: FQN,
+        stage_name: str,
+        default_target: Optional[str],
+        external_access_integrations: Optional[List[str]],
+    ) -> SnowflakeCursor:
+        # Project doesn't exist - create new one
+        query = f"CREATE DBT PROJECT {fqn}"
+        query += f"\nFROM {stage_name}"
+        if default_target:
+            query += f" DEFAULT_TARGET='{default_target}'"
+        query = self._handle_external_access_integrations_query(
+            query, external_access_integrations
+        )
+        return self.execute_query(query)
+
+    @staticmethod
+    def _handle_external_access_integrations_query(
+        query: str, external_access_integrations: Optional[List[str]]
+    ) -> str:
+        if external_access_integrations:
+            integrations_str = ", ".join(external_access_integrations)
+            query += f"\nEXTERNAL_ACCESS_INTEGRATIONS = ({integrations_str})"
+        return query
+
+    def _deploy_create_or_replace(
+        self,
+        fqn: FQN,
+        stage_name: str,
+        default_target: Optional[str],
+        external_access_integrations: Optional[List[str]],
+    ) -> SnowflakeCursor:
+        query = f"CREATE OR REPLACE DBT PROJECT {fqn}"
+        query += f"\nFROM {stage_name}"
+        if default_target:
+            query += f" DEFAULT_TARGET='{default_target}'"
+        query = self._handle_external_access_integrations_query(
+            query, external_access_integrations
+        )
+        return self.execute_query(query)
 
     @staticmethod
-    def _validate_profiles(profiles_path: SecurePath, target_profile: str) -> None:
+    def _validate_profiles(
+        profiles_path: SecurePath,
+        target_profile: str,
+        default_target: str | None = None,
+    ) -> None:
         """
         Validates that:
          * profiles.yml exists
          * contain profile specified in dbt_project.yml
          * no other profiles are defined there
          * does not contain any confidential data like passwords
+         * default_target (if specified) exists in the profile's outputs
         """
         profiles_file = profiles_path / PROFILES_FILENAME
         if not profiles_file.exists():
@@ -154,6 +277,15 @@ class DBTManager(SqlExecutionMixin):
                     f"Value for type field is invalid. Should be set to `snowflake` in target {target_name}"
                 )
 
+        if default_target is not None:
+            available_targets = set(profiles[target_profile]["outputs"].keys())
+            if default_target not in available_targets:
+                available_targets_str = ", ".join(sorted(available_targets))
+                errors["default_target"].append(
+                    f"Default target '{default_target}' is not defined in profile '{target_profile}'. "
+                    f"Available targets: {available_targets_str}"
+                )
+
         if errors:
             message = f"Found following errors in {PROFILES_FILENAME}. Please fix them before proceeding:"
             for target, issues in errors.items():