snowflake-cli-labs 3.0.0rc0__py3-none-any.whl → 3.0.0rc2__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,50 @@ 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.diff import DiffResult
+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.schemas.native_app.path_mapping import PathMapping
+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]):
@@ -40,23 +63,209 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
     A Native App application package.
     """
 
-    def action_bundle(self, ctx: ActionContext):
+    def action_bundle(self, ctx: ActionContext, *args, **kwargs):
         model = self._entity_model
-        bundle_map = build_bundle(
-            ctx.project_root, Path(model.deploy_root), model.artifacts
-        )
-        bundle_context = BundleContext(
+        return self.bundle(
+            project_root=ctx.project_root,
+            deploy_root=Path(model.deploy_root),
+            bundle_root=Path(model.bundle_root),
+            generated_root=Path(model.generated_root),
             package_name=model.identifier,
             artifacts=model.artifacts,
+        )
+
+    def action_deploy(
+        self,
+        ctx: ActionContext,
+        prune: bool,
+        recursive: bool,
+        paths: List[Path],
+        validate: bool,
+        stage_fqn: Optional[str] = None,
+        *args,
+        **kwargs,
+    ):
+        model = self._entity_model
+        package_name = model.fqn.identifier
+        return self.deploy(
+            console=ctx.console,
             project_root=ctx.project_root,
-            bundle_root=Path(model.bundle_root),
             deploy_root=Path(model.deploy_root),
+            bundle_root=Path(model.bundle_root),
             generated_root=Path(model.generated_root),
+            artifacts=model.artifacts,
+            package_name=package_name,
+            package_role=(model.meta and model.meta.role) or ctx.default_role,
+            package_distribution=model.distribution,
+            prune=prune,
+            recursive=recursive,
+            paths=paths,
+            print_diff=True,
+            validate=validate,
+            stage_fqn=stage_fqn or f"{package_name}.{model.stage}",
+            package_warehouse=(
+                (model.meta and model.meta.warehouse) or ctx.default_warehouse
+            ),
+            post_deploy_hooks=model.meta and model.meta.post_deploy,
+            package_scripts=[],  # Package scripts are not supported in PDFv2
+        )
+
+    def action_drop(self, ctx: ActionContext, force_drop: bool, *args, **kwargs):
+        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,
+        )
+
+    def action_validate(self, ctx: ActionContext, *args, **kwargs):
+        model = self._entity_model
+        package_name = model.fqn.identifier
+        stage_fqn = f"{package_name}.{model.stage}"
+        if model.meta and model.meta.role:
+            package_role = model.meta.role
+        else:
+            package_role = ctx.default_role
+
+        def deploy_to_scratch_stage_fn():
+            self.action_deploy(
+                ctx=ctx,
+                prune=True,
+                recursive=True,
+                paths=[],
+                validate=False,
+                stage_fqn=model.scratch_stage,
+            )
+
+        self.validate_setup_script(
+            console=ctx.console,
+            package_name=package_name,
+            package_role=package_role,
+            stage_fqn=stage_fqn,
+            use_scratch_stage=True,
+            scratch_stage_fqn=model.scratch_stage,
+            deploy_to_scratch_stage_fn=deploy_to_scratch_stage_fn,
+        )
+        ctx.console.message("Setup script is valid")
+
+    @staticmethod
+    def bundle(
+        project_root: Path,
+        deploy_root: Path,
+        bundle_root: Path,
+        generated_root: Path,
+        artifacts: list[PathMapping],
+        package_name: str,
+    ):
+        bundle_map = build_bundle(project_root, deploy_root, artifacts)
+        bundle_context = BundleContext(
+            package_name=package_name,
+            artifacts=artifacts,
+            project_root=project_root,
+            bundle_root=bundle_root,
+            deploy_root=deploy_root,
+            generated_root=generated_root,
         )
         compiler = NativeAppCompiler(bundle_context)
         compiler.compile_artifacts()
         return bundle_map
 
+    @classmethod
+    def deploy(
+        cls,
+        console: AbstractConsole,
+        project_root: Path,
+        deploy_root: Path,
+        bundle_root: Path,
+        generated_root: Path,
+        artifacts: list[PathMapping],
+        package_name: str,
+        package_role: str,
+        package_distribution: str,
+        package_warehouse: str | None,
+        prune: bool,
+        recursive: bool,
+        paths: List[Path],
+        print_diff: bool,
+        validate: bool,
+        stage_fqn: str,
+        post_deploy_hooks: list[PostDeployHook] | None,
+        package_scripts: List[str],
+    ) -> DiffResult:
+        # 1. Create a bundle
+        bundle_map = cls.bundle(
+            project_root=project_root,
+            deploy_root=deploy_root,
+            bundle_root=bundle_root,
+            generated_root=generated_root,
+            artifacts=artifacts,
+            package_name=package_name,
+        )
+
+        # 2. Create an empty application package, if none exists
+        cls.create_app_package(
+            console=console,
+            package_name=package_name,
+            package_role=package_role,
+            package_distribution=package_distribution,
+        )
+
+        with get_sql_executor().use_role(package_role):
+            if package_scripts:
+                cls.apply_package_scripts(
+                    console=console,
+                    package_scripts=package_scripts,
+                    package_warehouse=package_warehouse,
+                    project_root=project_root,
+                    package_role=package_role,
+                    package_name=package_name,
+                )
+
+            # 3. Upload files from deploy root local folder to the above stage
+            stage_schema = extract_schema(stage_fqn)
+            diff = sync_deploy_root_with_stage(
+                console=console,
+                deploy_root=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=print_diff,
+            )
+
+        if post_deploy_hooks:
+            cls.execute_post_deploy_hooks(
+                console=console,
+                project_root=project_root,
+                post_deploy_hooks=post_deploy_hooks,
+                package_name=package_name,
+                package_warehouse=package_warehouse,
+            )
+
+        if validate:
+            cls.validate_setup_script(
+                console=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,
+            )
+
+        return diff
+
     @staticmethod
     def get_existing_app_pkg_info(
         package_name: str,
@@ -178,9 +387,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 +467,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,9 @@ from snowflake.cli.api.sql_execution import SqlExecutor
 
 class EntityActions(str, Enum):
     BUNDLE = "action_bundle"
+    DEPLOY = "action_deploy"
+    DROP = "action_drop"
+    VALIDATE = "action_validate"
 
 
 T = TypeVar("T")
@@ -35,11 +38,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,19 +25,22 @@ 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
+from snowflake.connector.cursor import SnowflakeCursor
 
 
 def generic_sql_error_handler(
@@ -272,8 +275,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,35 +289,93 @@ 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.
     """
-    scripts_contents = []
-    for relpath in scripts:
-        script_full_path = SecurePath(project_root) / relpath
+    return [
+        render_script_template(project_root, jinja_context, script, override_env)
+        for script in scripts
+    ]
+
+
+def render_script_template(
+    project_root: Path,
+    jinja_context: dict[str, Any],
+    script: str,
+    override_env: Optional[jinja2.Environment] = None,
+) -> str:
+    script_full_path = SecurePath(project_root) / script
+    try:
+        template_content = script_full_path.read_text(file_size_limit_mb=UNLIMITED)
+        env = override_env or choose_sql_jinja_env_based_on_template_syntax(
+            template_content, reference_name=script
+        )
+        return env.from_string(template_content).render(jinja_context)
+
+    except FileNotFoundError as e:
+        raise MissingScriptError(script) from e
+
+    except jinja2.TemplateSyntaxError as e:
+        raise InvalidTemplateInFileError(script, e, e.lineno) from e
+
+    except jinja2.UndefinedError as e:
+        raise InvalidTemplateInFileError(script, e) from e
+
+
+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:
-            template_content = script_full_path.read_text(file_size_limit_mb=UNLIMITED)
-            result = render_from_str(template_content, jinja_context)
-            scripts_contents.append(result)
+            sql_executor.execute_query(drop_query)
+        except:
+            raise SnowflakeSQLExecutionError(drop_query)
 
-        except FileNotFoundError as e:
-            raise MissingScriptError(relpath) from e
+        console.message(f"Dropped {object_type} {object_name} successfully.")
 
-        except jinja2.TemplateSyntaxError as e:
-            raise InvalidScriptError(relpath, e, e.lineno) from e
 
-        except jinja2.UndefinedError as e:
-            raise InvalidScriptError(relpath, e) from e
+def print_messages(
+    console: AbstractConsole, create_or_upgrade_cursor: Optional[SnowflakeCursor]
+):
+    """
+    Shows messages in the console returned by the CREATE or UPGRADE
+    APPLICATION command.
+    """
+    if not create_or_upgrade_cursor:
+        return
 
-    return scripts_contents
+    messages = [row[0] for row in create_or_upgrade_cursor.fetchall()]
+    for message in messages:
+        console.warning(message)
+    console.message("")

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):