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

snowflake/cli/_plugins/nativeapp/manager.py

@@ -14,32 +14,20 @@
 
 from __future__ import annotations
 
-import json
 import time
 from abc import ABC, abstractmethod
-from contextlib import contextmanager
 from datetime import datetime
 from functools import cached_property
 from pathlib import Path
 from textwrap import dedent
-from typing import Generator, List, Optional, TypedDict
+from typing import Generator, List, Optional
 
-from click import ClickException
 from snowflake.cli._plugins.connection.util import make_snowsight_url
 from snowflake.cli._plugins.nativeapp.artifacts import (
     BundleMap,
-    build_bundle,
-)
-from snowflake.cli._plugins.nativeapp.codegen.compiler import (
-    NativeAppCompiler,
-)
-from snowflake.cli._plugins.nativeapp.constants import (
-    NAME_COL,
 )
 from snowflake.cli._plugins.nativeapp.exceptions import (
-    ApplicationPackageDoesNotExistError,
     NoEventTableForAccount,
-    SetupScriptFailedValidation,
 )
 from snowflake.cli._plugins.nativeapp.project_model import (
     NativeAppProjectModel,
@@ -47,8 +35,11 @@ from snowflake.cli._plugins.nativeapp.project_model import (
 from snowflake.cli._plugins.stage.diff import (
     DiffResult,
 )
-from snowflake.cli._plugins.stage.manager import StageManager
 from snowflake.cli.api.console import cli_console as cc
+from snowflake.cli.api.entities.application_entity import (
+    ApplicationEntity,
+    ApplicationOwnedObject,
+)
 from snowflake.cli.api.entities.application_package_entity import (
     ApplicationPackageEntity,
 )
@@ -57,10 +48,6 @@ from snowflake.cli.api.entities.utils import (
     generic_sql_error_handler,
     sync_deploy_root_with_stage,
 )
-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.common import PostDeployHook
 from snowflake.cli.api.project.schemas.native_app.native_app import NativeApp
 from snowflake.cli.api.project.schemas.native_app.path_mapping import PathMapping
@@ -71,8 +58,6 @@ from snowflake.cli.api.project.util import (
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector import DictCursor, ProgrammingError
 
-ApplicationOwnedObject = TypedDict("ApplicationOwnedObject", {"name": str, "type": str})
-
 
 class NativeAppCommandProcessor(ABC):
     @abstractmethod
@@ -149,20 +134,8 @@ class NativeAppManager(SqlExecutionMixin):
     def application_warehouse(self) -> Optional[str]:
         return self.na_project.application_warehouse
 
-    @contextmanager
     def use_application_warehouse(self):
-        if self.application_warehouse:
-            with self.use_warehouse(self.application_warehouse):
-                yield
-        else:
-            raise ClickException(
-                dedent(
-                    f"""\
-                Application warehouse cannot be empty.
-                Please provide a value for it in your connection information or your project definition file.
-                """
-                )
-            )
+        return ApplicationEntity.use_application_warehouse(self.application_warehouse)
 
     @property
     def project_identifier(self) -> str:
@@ -227,10 +200,14 @@ class NativeAppManager(SqlExecutionMixin):
         """
         Populates the local deploy root from artifact sources.
         """
-        bundle_map = build_bundle(self.project_root, self.deploy_root, self.artifacts)
-        compiler = NativeAppCompiler(self.na_project.get_bundle_context())
-        compiler.compile_artifacts()
-        return bundle_map
+        return ApplicationPackageEntity.bundle(
+            project_root=self.project_root,
+            deploy_root=self.deploy_root,
+            bundle_root=self.bundle_root,
+            generated_root=self.generated_root,
+            package_name=self.package_name,
+            artifacts=self.artifacts,
+        )
 
     def sync_deploy_root_with_stage(
         self,
@@ -257,14 +234,10 @@ class NativeAppManager(SqlExecutionMixin):
         )
 
     def get_existing_app_info(self) -> Optional[dict]:
-        """
-        Check for an existing application object by the same name as in project definition, in account.
-        It executes a 'show applications like' query and returns the result as single row, if one exists.
-        """
-        with self.use_role(self.app_role):
-            return self.show_specific_object(
-                "applications", self.app_name, name_col=NAME_COL
-            )
+        return ApplicationEntity.get_existing_app_info(
+            app_name=self.app_name,
+            app_role=self.app_role,
+        )
 
     def get_existing_app_pkg_info(self) -> Optional[dict]:
         return ApplicationPackageEntity.get_existing_app_pkg_info(
@@ -272,32 +245,19 @@ class NativeAppManager(SqlExecutionMixin):
             package_role=self.package_role,
         )
 
-    def get_objects_owned_by_application(self) -> List[ApplicationOwnedObject]:
-        """
-        Returns all application objects owned by this application.
-        """
-        with self.use_role(self.app_role):
-            results = self._execute_query(
-                f"show objects owned by application {self.app_name}"
-            ).fetchall()
-            return [{"name": row[1], "type": row[2]} for row in results]
+    def get_objects_owned_by_application(self):
+        return ApplicationEntity.get_objects_owned_by_application(
+            app_name=self.app_name,
+            app_role=self.app_role,
+        )
 
     def _application_objects_to_str(
         self, application_objects: list[ApplicationOwnedObject]
     ) -> str:
-        """
-        Returns a list in an "(Object Type) Object Name" format. Database-level and schema-level object names are fully qualified:
-        (COMPUTE_POOL) POOL_NAME
-        (DATABASE) DB_NAME
-        (SCHEMA) DB_NAME.PUBLIC
-        ...
-        """
-        return "\n".join(
-            [self._application_object_to_str(obj) for obj in application_objects]
-        )
+        return ApplicationEntity.application_objects_to_str(application_objects)
 
-    def _application_object_to_str(self, obj: ApplicationOwnedObject) -> str:
-        return f"({obj['type']}) {obj['name']}"
+    def _application_object_to_str(self, obj: ApplicationOwnedObject):
+        return ApplicationEntity.application_object_to_str(obj)
 
     def get_snowsight_url(self) -> str:
         """Returns the URL that can be used to visit this app via Snowsight."""
@@ -351,89 +311,59 @@ class NativeAppManager(SqlExecutionMixin):
         validate: bool = True,
         print_diff: bool = True,
     ) -> DiffResult:
-        """app deploy process"""
-
-        # 1. Create an empty application package, if none exists
-        self.create_app_package()
-
-        with self.use_role(self.package_role):
-            # 2. now that the application package exists, create shared data
-            self._apply_package_scripts()
-
-            # 3. Upload files from deploy root local folder to the above stage
-            stage_fqn = stage_fqn or self.stage_fqn
-            diff = self.sync_deploy_root_with_stage(
-                bundle_map=bundle_map,
-                role=self.package_role,
-                prune=prune,
-                recursive=recursive,
-                stage_fqn=stage_fqn,
-                local_paths_to_sync=local_paths_to_sync,
-                print_diff=print_diff,
-            )
-
-            # 4. Execute post-deploy hooks
-            with self.use_package_warehouse():
-                self.execute_package_post_deploy_hooks()
-
-        if validate:
-            self.validate(use_scratch_stage=False)
+        return ApplicationPackageEntity.deploy(
+            console=cc,
+            project_root=self.project_root,
+            deploy_root=self.deploy_root,
+            bundle_root=self.bundle_root,
+            generated_root=self.generated_root,
+            artifacts=self.artifacts,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            package_distribution=self.package_distribution,
+            prune=prune,
+            recursive=recursive,
+            paths=local_paths_to_sync,
+            print_diff=print_diff,
+            validate=validate,
+            stage_fqn=stage_fqn or self.stage_fqn,
+            package_warehouse=self.package_warehouse,
+            post_deploy_hooks=self.package_post_deploy_hooks,
+            package_scripts=self.package_scripts,
+        )
 
-        return diff
+    def deploy_to_scratch_stage_fn(self):
+        bundle_map = self.build_bundle()
+        self.deploy(
+            bundle_map=bundle_map,
+            prune=True,
+            recursive=True,
+            stage_fqn=self.scratch_stage_fqn,
+            validate=False,
+            print_diff=False,
+        )
 
     def validate(self, use_scratch_stage: bool = False):
-        """Validates Native App setup script SQL."""
-        with cc.phase(f"Validating Snowflake Native App setup script."):
-            validation_result = self.get_validation_result(use_scratch_stage)
-
-            # First print warnings, regardless of the outcome of validation
-            for warning in validation_result.get("warnings", []):
-                cc.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
-                cc.warning(_validation_item_to_str(error))
-
-            # Then raise an exception if validation failed
-            if validation_result["status"] == "FAIL":
-                raise SetupScriptFailedValidation()
+        return ApplicationPackageEntity.validate_setup_script(
+            console=cc,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            stage_fqn=self.stage_fqn,
+            use_scratch_stage=use_scratch_stage,
+            scratch_stage_fqn=self.scratch_stage_fqn,
+            deploy_to_scratch_stage_fn=self.deploy_to_scratch_stage_fn,
+        )
 
     def get_validation_result(self, use_scratch_stage: bool):
-        """Call system$validate_native_app_setup() to validate deployed Native App setup script."""
-        stage_fqn = self.stage_fqn
-        if use_scratch_stage:
-            stage_fqn = self.scratch_stage_fqn
-            bundle_map = self.build_bundle()
-            self.deploy(
-                bundle_map=bundle_map,
-                prune=True,
-                recursive=True,
-                stage_fqn=stage_fqn,
-                validate=False,
-                print_diff=False,
-            )
-        prefixed_stage_fqn = StageManager.get_standard_stage_prefix(stage_fqn)
-        try:
-            cursor = self._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(self.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:
-                cc.step(f"Dropping stage {self.scratch_stage_fqn}.")
-                with self.use_role(self.package_role):
-                    self._execute_query(
-                        f"drop stage if exists {self.scratch_stage_fqn}"
-                    )
+        return ApplicationPackageEntity.get_validation_result(
+            console=cc,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            stage_fqn=self.stage_fqn,
+            use_scratch_stage=use_scratch_stage,
+            scratch_stage_fqn=self.scratch_stage_fqn,
+            deploy_to_scratch_stage_fn=self.deploy_to_scratch_stage_fn,
+        )
 
     def get_events(  # type: ignore [return]
         self,

snowflake/cli/_plugins/nativeapp/project_model.py

@@ -21,6 +21,7 @@ from typing import List, Optional
 from snowflake.cli._plugins.nativeapp.artifacts import resolve_without_follow
 from snowflake.cli._plugins.nativeapp.bundle_context import BundleContext
 from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.entities.common import get_sql_executor
 from snowflake.cli.api.project.definition import (
     default_app_package,
     default_application,
@@ -34,14 +35,6 @@ from snowflake.cli.api.project.util import (
     extract_schema,
     to_identifier,
 )
-from snowflake.connector import DictCursor
-
-
-def current_role() -> str:
-    conn = get_cli_context().connection
-    *_, cursor = conn.execute_string("select current_role()", cursor_class=DictCursor)
-    role_result = cursor.fetchone()
-    return role_result["CURRENT_ROLE()"]
 
 
 class NativeAppProjectModel:
@@ -198,7 +191,7 @@ class NativeAppProjectModel:
     def _default_role(self) -> str:
         role = default_role()
         if role is None:
-            role = current_role()
+            role = get_sql_executor().current_role()
         return role
 
     @cached_property