snowflake-cli-labs 3.0.0rc0__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

snowflake/cli/api/entities/application_package_entity.py

@@ -1,8 +1,10 @@
+import json
 from contextlib import contextmanager
 from pathlib import Path
 from textwrap import dedent
-from typing import List, Optional
+from typing import Callable, List, Optional
 
+import typer
 from click import ClickException
 from snowflake.cli._plugins.nativeapp.artifacts import build_bundle
 from snowflake.cli._plugins.nativeapp.bundle_context import BundleContext
@@ -10,29 +12,48 @@ from snowflake.cli._plugins.nativeapp.codegen.compiler import NativeAppCompiler
 from snowflake.cli._plugins.nativeapp.constants import (
     ALLOWED_SPECIAL_COMMENTS,
     COMMENT_COL,
+    EXTERNAL_DISTRIBUTION,
     INTERNAL_DISTRIBUTION,
     NAME_COL,
+    OWNER_COL,
     SPECIAL_COMMENT,
 )
 from snowflake.cli._plugins.nativeapp.exceptions import (
     ApplicationPackageAlreadyExistsError,
+    ApplicationPackageDoesNotExistError,
+    CouldNotDropApplicationPackageWithVersions,
+    SetupScriptFailedValidation,
 )
+from snowflake.cli._plugins.nativeapp.utils import (
+    needs_confirmation,
+)
+from snowflake.cli._plugins.stage.manager import StageManager
 from snowflake.cli._plugins.workspace.action_context import ActionContext
 from snowflake.cli.api.console.abc import AbstractConsole
 from snowflake.cli.api.entities.common import EntityBase, get_sql_executor
 from snowflake.cli.api.entities.utils import (
+    drop_generic_object,
     ensure_correct_owner,
+    execute_post_deploy_hooks,
     generic_sql_error_handler,
     render_script_templates,
+    sync_deploy_root_with_stage,
+    validation_item_to_str,
+)
+from snowflake.cli.api.errno import (
+    DOES_NOT_EXIST_OR_NOT_AUTHORIZED,
 )
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
 from snowflake.cli.api.project.schemas.entities.application_package_entity_model import (
     ApplicationPackageEntityModel,
 )
+from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
+from snowflake.cli.api.project.util import extract_schema
 from snowflake.cli.api.rendering.jinja import (
-    jinja_render_from_str,
+    get_basic_jinja_env,
 )
 from snowflake.connector import ProgrammingError
+from snowflake.connector.cursor import DictCursor
 
 
 class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
@@ -57,6 +78,89 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         compiler.compile_artifacts()
         return bundle_map
 
+    def action_deploy(
+        self,
+        ctx: ActionContext,
+        prune: bool,
+        recursive: bool,
+        paths: List[Path],
+        validate: bool,
+    ):
+        model = self._entity_model
+        package_name = model.fqn.identifier
+        if model.meta and model.meta.role:
+            package_role = model.meta.role
+        else:
+            package_role = ctx.default_role
+
+        # 1. Create a bundle
+        bundle_map = self.action_bundle(ctx)
+
+        # 2. Create an empty application package, if none exists
+        self.create_app_package(
+            console=ctx.console,
+            package_name=package_name,
+            package_role=package_role,
+            package_distribution=model.distribution,
+        )
+
+        with get_sql_executor().use_role(package_role):
+            # 3. Upload files from deploy root local folder to the above stage
+            stage_fqn = f"{package_name}.{model.stage}"
+            stage_schema = extract_schema(stage_fqn)
+            sync_deploy_root_with_stage(
+                console=ctx.console,
+                deploy_root=Path(model.deploy_root),
+                package_name=package_name,
+                stage_schema=stage_schema,
+                bundle_map=bundle_map,
+                role=package_role,
+                prune=prune,
+                recursive=recursive,
+                stage_fqn=stage_fqn,
+                local_paths_to_sync=paths,
+                print_diff=True,
+            )
+
+        if model.meta and model.meta.post_deploy:
+            self.execute_post_deploy_hooks(
+                console=ctx.console,
+                project_root=ctx.project_root,
+                post_deploy_hooks=model.meta.post_deploy,
+                package_name=package_name,
+                package_warehouse=model.meta.warehouse or ctx.default_warehouse,
+            )
+
+        if validate:
+            self.validate_setup_script(
+                console=ctx.console,
+                package_name=package_name,
+                package_role=package_role,
+                stage_fqn=stage_fqn,
+                use_scratch_stage=False,
+                scratch_stage_fqn="",
+                deploy_to_scratch_stage_fn=lambda *args: None,
+            )
+
+    def action_drop(
+        self,
+        ctx: ActionContext,
+        force_drop: bool,
+    ):
+        model = self._entity_model
+        package_name = model.fqn.identifier
+        if model.meta and model.meta.role:
+            package_role = model.meta.role
+        else:
+            package_role = ctx.default_role
+
+        self.drop(
+            console=ctx.console,
+            package_name=package_name,
+            package_role=package_role,
+            force_drop=force_drop,
+        )
+
     @staticmethod
     def get_existing_app_pkg_info(
         package_name: str,
@@ -178,9 +282,9 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
 
         queued_queries = render_script_templates(
             project_root,
-            jinja_render_from_str,
             dict(package_name=package_name),
             package_scripts,
+            get_basic_jinja_env(),
         )
 
         # once we're sure all the templates expanded correctly, execute all of them
@@ -258,3 +362,192 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
                 """
                 )
             )
+
+    @classmethod
+    def execute_post_deploy_hooks(
+        cls,
+        console: AbstractConsole,
+        project_root: Path,
+        post_deploy_hooks: Optional[List[PostDeployHook]],
+        package_name: str,
+        package_warehouse: Optional[str],
+    ):
+        with cls.use_package_warehouse(package_warehouse):
+            execute_post_deploy_hooks(
+                console=console,
+                project_root=project_root,
+                post_deploy_hooks=post_deploy_hooks,
+                deployed_object_type="application package",
+                database_name=package_name,
+            )
+
+    @classmethod
+    def validate_setup_script(
+        cls,
+        console: AbstractConsole,
+        package_name: str,
+        package_role: str,
+        stage_fqn: str,
+        use_scratch_stage: bool,
+        scratch_stage_fqn: str,
+        deploy_to_scratch_stage_fn: Callable,
+    ):
+        """Validates Native App setup script SQL."""
+        with console.phase(f"Validating Snowflake Native App setup script."):
+            validation_result = cls.get_validation_result(
+                console=console,
+                package_name=package_name,
+                package_role=package_role,
+                stage_fqn=stage_fqn,
+                use_scratch_stage=use_scratch_stage,
+                scratch_stage_fqn=scratch_stage_fqn,
+                deploy_to_scratch_stage_fn=deploy_to_scratch_stage_fn,
+            )
+
+            # First print warnings, regardless of the outcome of validation
+            for warning in validation_result.get("warnings", []):
+                console.warning(validation_item_to_str(warning))
+
+            # Then print errors
+            for error in validation_result.get("errors", []):
+                # Print them as warnings for now since we're going to be
+                # revamping CLI output soon
+                console.warning(validation_item_to_str(error))
+
+            # Then raise an exception if validation failed
+            if validation_result["status"] == "FAIL":
+                raise SetupScriptFailedValidation()
+
+    @staticmethod
+    def get_validation_result(
+        console: AbstractConsole,
+        package_name: str,
+        package_role: str,
+        stage_fqn: str,
+        use_scratch_stage: bool,
+        scratch_stage_fqn: str,
+        deploy_to_scratch_stage_fn: Callable,
+    ):
+        """Call system$validate_native_app_setup() to validate deployed Native App setup script."""
+        if use_scratch_stage:
+            stage_fqn = scratch_stage_fqn
+            deploy_to_scratch_stage_fn()
+        prefixed_stage_fqn = StageManager.get_standard_stage_prefix(stage_fqn)
+        sql_executor = get_sql_executor()
+        try:
+            cursor = sql_executor.execute_query(
+                f"call system$validate_native_app_setup('{prefixed_stage_fqn}')"
+            )
+        except ProgrammingError as err:
+            if err.errno == DOES_NOT_EXIST_OR_NOT_AUTHORIZED:
+                raise ApplicationPackageDoesNotExistError(package_name)
+            generic_sql_error_handler(err)
+        else:
+            if not cursor.rowcount:
+                raise SnowflakeSQLExecutionError()
+            return json.loads(cursor.fetchone()[0])
+        finally:
+            if use_scratch_stage:
+                console.step(f"Dropping stage {scratch_stage_fqn}.")
+                with sql_executor.use_role(package_role):
+                    sql_executor.execute_query(
+                        f"drop stage if exists {scratch_stage_fqn}"
+                    )
+
+    @classmethod
+    def drop(
+        cls,
+        console: AbstractConsole,
+        package_name: str,
+        package_role: str,
+        force_drop: bool,
+    ):
+        sql_executor = get_sql_executor()
+        needs_confirm = True
+
+        # 1. If existing application package is not found, exit gracefully
+        show_obj_row = cls.get_existing_app_pkg_info(
+            package_name=package_name,
+            package_role=package_role,
+        )
+        if show_obj_row is None:
+            console.warning(
+                f"Role {package_role} does not own any application package with the name {package_name}, or the application package does not exist."
+            )
+            return
+
+        # 2. Check for the right owner
+        ensure_correct_owner(row=show_obj_row, role=package_role, obj_name=package_name)
+
+        with sql_executor.use_role(package_role):
+            # 3. Check for versions in the application package
+            show_versions_query = f"show versions in application package {package_name}"
+            show_versions_cursor = sql_executor.execute_query(
+                show_versions_query, cursor_class=DictCursor
+            )
+            if show_versions_cursor.rowcount is None:
+                raise SnowflakeSQLExecutionError(show_versions_query)
+
+            if show_versions_cursor.rowcount > 0:
+                # allow dropping a package with versions when --force is set
+                if not force_drop:
+                    raise CouldNotDropApplicationPackageWithVersions(
+                        "Drop versions first, or use --force to override."
+                    )
+
+        # 4. Check distribution of the existing application package
+        actual_distribution = cls.get_app_pkg_distribution_in_snowflake(
+            package_name=package_name,
+            package_role=package_role,
+        )
+        if not cls.verify_project_distribution(
+            console=console,
+            package_name=package_name,
+            package_role=package_role,
+            package_distribution=actual_distribution,
+        ):
+            console.warning(
+                f"Dropping application package {package_name} with distribution '{actual_distribution}'."
+            )
+
+        # 5. If distribution is internal, check if created by the Snowflake CLI
+        row_comment = show_obj_row[COMMENT_COL]
+        if actual_distribution == INTERNAL_DISTRIBUTION:
+            if row_comment in ALLOWED_SPECIAL_COMMENTS:
+                needs_confirm = False
+            else:
+                if needs_confirmation(needs_confirm, force_drop):
+                    console.warning(
+                        f"Application package {package_name} was not created by Snowflake CLI."
+                    )
+        else:
+            if needs_confirmation(needs_confirm, force_drop):
+                console.warning(
+                    f"Application package {package_name} in your Snowflake account has distribution property '{EXTERNAL_DISTRIBUTION}' and could be associated with one or more of your listings on Snowflake Marketplace."
+                )
+
+        if needs_confirmation(needs_confirm, force_drop):
+            should_drop_object = typer.confirm(
+                dedent(
+                    f"""\
+                        Application package details:
+                        Name: {package_name}
+                        Created on: {show_obj_row["created_on"]}
+                        Distribution: {actual_distribution}
+                        Owner: {show_obj_row[OWNER_COL]}
+                        Comment: {show_obj_row[COMMENT_COL]}
+                        Are you sure you want to drop it?
+                    """
+                )
+            )
+            if not should_drop_object:
+                console.message(f"Did not drop application package {package_name}.")
+                return  # The user desires to keep the application package, therefore exit gracefully
+
+        # All validations have passed, drop object
+        drop_generic_object(
+            console=console,
+            object_type="application package",
+            object_name=package_name,
+            role=package_role,
+        )

snowflake/cli/api/entities/common.py

@@ -7,6 +7,8 @@ from snowflake.cli.api.sql_execution import SqlExecutor
 
 class EntityActions(str, Enum):
     BUNDLE = "action_bundle"
+    DEPLOY = "action_deploy"
+    DROP = "action_drop"
 
 
 T = TypeVar("T")
@@ -35,11 +37,13 @@ class EntityBase(Generic[T]):
         """
         return callable(getattr(self, action, None))
 
-    def perform(self, action: EntityActions, action_ctx: ActionContext):
+    def perform(
+        self, action: EntityActions, action_ctx: ActionContext, *args, **kwargs
+    ):
         """
         Performs the requested action.
         """
-        return getattr(self, action)(action_ctx)
+        return getattr(self, action)(action_ctx, *args, **kwargs)
 
 
 def get_sql_executor() -> SqlExecutor:

snowflake/cli/api/entities/utils.py

@@ -1,7 +1,7 @@
 import os
 from pathlib import Path
 from textwrap import dedent
-from typing import Any, Callable, Dict, List, NoReturn, Optional
+from typing import Any, List, NoReturn, Optional
 
 import jinja2
 from click import ClickException
@@ -11,7 +11,7 @@ from snowflake.cli._plugins.nativeapp.artifacts import (
 )
 from snowflake.cli._plugins.nativeapp.constants import OWNER_COL
 from snowflake.cli._plugins.nativeapp.exceptions import (
-    InvalidScriptError,
+    InvalidTemplateInFileError,
     MissingScriptError,
     UnexpectedOwnerError,
 )
@@ -25,16 +25,18 @@ from snowflake.cli._plugins.stage.diff import (
     to_stage_path,
 )
 from snowflake.cli._plugins.stage.utils import print_diff_to_console
+from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.console.abc import AbstractConsole
 from snowflake.cli.api.entities.common import get_sql_executor
 from snowflake.cli.api.errno import (
     DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED,
     NO_WAREHOUSE_SELECTED_IN_SESSION,
 )
+from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
 from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
 from snowflake.cli.api.project.util import unquote_identifier
 from snowflake.cli.api.rendering.sql_templates import (
-    snowflake_sql_jinja_render,
+    choose_sql_jinja_env_based_on_template_syntax,
 )
 from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
 from snowflake.connector import ProgrammingError
@@ -272,8 +274,7 @@ def execute_post_deploy_hooks(
 
         scripts_content_list = render_script_templates(
             project_root,
-            snowflake_sql_jinja_render,
-            {},
+            get_cli_context().template_context,
             sql_scripts_paths,
         )
 
@@ -287,16 +288,17 @@ def execute_post_deploy_hooks(
 
 def render_script_templates(
     project_root: Path,
-    render_from_str: Callable[[str, Dict[str, Any]], str],
     jinja_context: dict[str, Any],
     scripts: List[str],
+    override_env: Optional[jinja2.Environment] = None,
 ) -> List[str]:
     """
     Input:
     - project_root: path to project root
-    - render_from_str: function which renders a jinja template from a string and jinja context
     - jinja_context: a dictionary with the jinja context
     - scripts: list of script paths relative to the project root
+    - override_env: optional jinja environment to use for rendering,
+      if not provided, the environment will be chosen based on the template syntax
     Returns:
     - List of rendered scripts content
     Size of the return list is the same as the size of the input scripts list.
@@ -306,16 +308,50 @@ def render_script_templates(
         script_full_path = SecurePath(project_root) / relpath
         try:
             template_content = script_full_path.read_text(file_size_limit_mb=UNLIMITED)
-            result = render_from_str(template_content, jinja_context)
+            env = override_env or choose_sql_jinja_env_based_on_template_syntax(
+                template_content, reference_name=relpath
+            )
+            result = env.from_string(template_content).render(jinja_context)
             scripts_contents.append(result)
 
         except FileNotFoundError as e:
             raise MissingScriptError(relpath) from e
 
         except jinja2.TemplateSyntaxError as e:
-            raise InvalidScriptError(relpath, e, e.lineno) from e
+            raise InvalidTemplateInFileError(relpath, e, e.lineno) from e
 
         except jinja2.UndefinedError as e:
-            raise InvalidScriptError(relpath, e) from e
+            raise InvalidTemplateInFileError(relpath, e) from e
 
     return scripts_contents
+
+
+def validation_item_to_str(item: dict[str, str | int]):
+    s = item["message"]
+    if item["errorCode"]:
+        s = f"{s} (error code {item['errorCode']})"
+    return s
+
+
+def drop_generic_object(
+    console: AbstractConsole,
+    object_type: str,
+    object_name: str,
+    role: str,
+    cascade: bool = False,
+):
+    """
+    Drop object using the given role.
+    """
+    sql_executor = get_sql_executor()
+    with sql_executor.use_role(role):
+        console.step(f"Dropping {object_type} {object_name} now.")
+        drop_query = f"drop {object_type} {object_name}"
+        if cascade:
+            drop_query += " cascade"
+        try:
+            sql_executor.execute_query(drop_query)
+        except:
+            raise SnowflakeSQLExecutionError(drop_query)
+
+        console.message(f"Dropped {object_type} {object_name} successfully.")

snowflake/cli/api/exceptions.py

@@ -19,6 +19,7 @@ from typing import Optional
 
 from click.exceptions import ClickException, UsageError
 from snowflake.cli.api.constants import ObjectType
+from snowflake.connector.compat import IS_WINDOWS
 
 
 class EnvironmentVariableNotFoundError(ClickException):
@@ -140,9 +141,18 @@ class DirectoryIsNotEmptyError(ClickException):
 
 class ConfigFileTooWidePermissionsError(ClickException):
     def __init__(self, path: Path):
-        super().__init__(
-            f'Configuration file {path} has too wide permissions, run `chmod 0600 "{path}"`'
+        change_permissons_command = (
+            f'icacls "{path}" /deny <USER_ID>:F'
+            if IS_WINDOWS
+            else f'chmod 0600 "{path}"'
         )
+        msg = f"Configuration file {path} has too wide permissions, run `{change_permissons_command}`."
+        if IS_WINDOWS:
+            msg += (
+                f'\nTo check which users have access to the file run `icacls "{path}"`.'
+                "Run the above command for all users except you and administrators."
+            )
+        super().__init__(msg)
 
 
 class DatabaseNotProvidedError(ClickException):

snowflake/cli/api/feature_flags.py

@@ -52,5 +52,3 @@ class FeatureFlag(FeatureFlagMixin):
     ENABLE_STREAMLIT_VERSIONED_STAGE = BooleanFlag(
         "ENABLE_STREAMLIT_VERSIONED_STAGE", False
     )
-    # TODO: remove in 3.0
-    ENABLE_PROJECT_DEFINITION_V2 = BooleanFlag("ENABLE_PROJECT_DEFINITION_V2", True)

snowflake/cli/api/project/definition.py

@@ -18,6 +18,7 @@ from pathlib import Path
 from typing import List, Optional
 
 import yaml
+from click import ClickException
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
 from snowflake.cli.api.project.schemas.project_definition import (
@@ -45,8 +46,13 @@ def _get_merged_definitions(paths: List[Path]) -> Optional[Definition]:
     if len(spaths) == 0:
         return None
 
+    loader = yaml.BaseLoader
+    loader.add_constructor(
+        yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, _no_duplicates_constructor
+    )
+
     with spaths[0].open("r", read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB) as base_yml:
-        definition = yaml.load(base_yml.read(), Loader=yaml.loader.BaseLoader) or {}
+        definition = yaml.load(base_yml.read(), Loader=loader) or {}
 
     for override_path in spaths[1:]:
         with override_path.open(
@@ -90,3 +96,20 @@ def default_role():
 def default_application(project_name: str):
     user = sanitize_identifier(get_env_username() or DEFAULT_USERNAME).lower()
     return append_to_identifier(to_identifier(project_name), f"_{user}")
+
+
+def _no_duplicates_constructor(loader, node, deep=False):
+    """
+    Raises error it there are duplicated keys on the same level in the yaml file
+    """
+    mapping = {}
+
+    for key_node, value_node in node.value:
+        key = loader.construct_object(key_node, deep=deep)
+        value = loader.construct_object(value_node, deep=deep)
+        if key in mapping.keys():
+            raise ClickException(
+                f"While loading the project definition file, duplicate key was found: {key}"
+            )
+        mapping[key] = value
+    return loader.construct_mapping(node, deep)