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

snowflake/cli/_plugins/nativeapp/manager.py

@@ -16,24 +16,15 @@ from __future__ import annotations
 
 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 (
     NoEventTableForAccount,
@@ -45,6 +36,10 @@ from snowflake.cli._plugins.stage.diff import (
     DiffResult,
 )
 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,
 )
@@ -63,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
@@ -141,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:
@@ -219,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,
@@ -249,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(
@@ -264,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."""
@@ -343,35 +311,26 @@ 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 diff
+        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,
+        )
 
     def deploy_to_scratch_stage_fn(self):
         bundle_map = self.build_bundle()

snowflake/cli/_plugins/nativeapp/run_processor.py

@@ -15,135 +15,33 @@
 from __future__ import annotations
 
 from pathlib import Path
-from textwrap import dedent
 from typing import Optional
 
 import typer
-from click import UsageError
 from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
-from snowflake.cli._plugins.nativeapp.constants import (
-    ALLOWED_SPECIAL_COMMENTS,
-    COMMENT_COL,
-    PATCH_COL,
-    SPECIAL_COMMENT,
-    VERSION_COL,
-)
-from snowflake.cli._plugins.nativeapp.exceptions import (
-    ApplicationCreatedExternallyError,
-    ApplicationPackageDoesNotExistError,
-)
 from snowflake.cli._plugins.nativeapp.manager import (
     NativeAppCommandProcessor,
     NativeAppManager,
 )
 from snowflake.cli._plugins.nativeapp.policy import PolicyBase
-from snowflake.cli._plugins.nativeapp.project_model import (
-    NativeAppProjectModel,
+from snowflake.cli._plugins.nativeapp.same_account_install_method import (
+    SameAccountInstallMethod,
 )
-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,
+)
 from snowflake.cli.api.entities.utils import (
-    ensure_correct_owner,
     generic_sql_error_handler,
 )
 from snowflake.cli.api.errno import (
     APPLICATION_NO_LONGER_AVAILABLE,
     APPLICATION_OWNS_EXTERNAL_OBJECTS,
-    CANNOT_UPGRADE_FROM_LOOSE_FILES_TO_VERSION,
-    CANNOT_UPGRADE_FROM_VERSION_TO_LOOSE_FILES,
-    NOT_SUPPORTED_ON_DEV_MODE_APPLICATIONS,
-    ONLY_SUPPORTED_ON_DEV_MODE_APPLICATIONS,
 )
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
 from snowflake.cli.api.project.schemas.native_app.native_app import NativeApp
-from snowflake.cli.api.project.util import (
-    identifier_to_show_like_pattern,
-    unquote_identifier,
-)
-from snowflake.cli.api.utils.cursor import find_all_rows
 from snowflake.connector import ProgrammingError
-from snowflake.connector.cursor import DictCursor, SnowflakeCursor
-
-# Reasons why an `alter application ... upgrade` might fail
-UPGRADE_RESTRICTION_CODES = {
-    CANNOT_UPGRADE_FROM_LOOSE_FILES_TO_VERSION,
-    CANNOT_UPGRADE_FROM_VERSION_TO_LOOSE_FILES,
-    ONLY_SUPPORTED_ON_DEV_MODE_APPLICATIONS,
-    NOT_SUPPORTED_ON_DEV_MODE_APPLICATIONS,
-    APPLICATION_NO_LONGER_AVAILABLE,
-}
-
-
-def print_messages(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
-
-    messages = [row[0] for row in create_or_upgrade_cursor.fetchall()]
-    for message in messages:
-        cc.warning(message)
-    cc.message("")
-
-
-class SameAccountInstallMethod:
-    _requires_created_by_cli: bool
-    _from_release_directive: bool
-    version: Optional[str]
-    patch: Optional[int]
-
-    def __init__(
-        self,
-        requires_created_by_cli: bool,
-        version: Optional[str] = None,
-        patch: Optional[int] = None,
-        from_release_directive: bool = False,
-    ):
-        self._requires_created_by_cli = requires_created_by_cli
-        self.version = version
-        self.patch = patch
-        self._from_release_directive = from_release_directive
-
-    @classmethod
-    def unversioned_dev(cls):
-        """aka. stage dev aka loose files"""
-        return cls(True)
-
-    @classmethod
-    def versioned_dev(cls, version: str, patch: Optional[int] = None):
-        return cls(False, version, patch)
-
-    @classmethod
-    def release_directive(cls):
-        return cls(False, from_release_directive=True)
-
-    @property
-    def is_dev_mode(self) -> bool:
-        return not self._from_release_directive
-
-    def using_clause(self, app: NativeAppProjectModel) -> str:
-        if self._from_release_directive:
-            return ""
-
-        if self.version:
-            patch_clause = f"patch {self.patch}" if self.patch else ""
-            return f"using version {self.version} {patch_clause}"
-
-        stage_name = StageManager.quote_stage_name(app.stage_fqn)
-        return f"using {stage_name}"
-
-    def ensure_app_usable(self, app: NativeAppProjectModel, show_app_row: dict):
-        """Raise an exception if we cannot proceed with install given the pre-existing application object"""
-
-        if self._requires_created_by_cli:
-            if show_app_row[COMMENT_COL] not in ALLOWED_SPECIAL_COMMENTS:
-                # this application object was not created by this tooling
-                raise ApplicationCreatedExternallyError(app.app_name)
-
-        # expected owner
-        ensure_correct_owner(row=show_app_row, role=app.app_role, obj_name=app.app_name)
+from snowflake.connector.cursor import SnowflakeCursor
 
 
 class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
@@ -165,35 +63,11 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
             return show_obj_cursor
 
     def get_existing_version_info(self, version: str) -> Optional[dict]:
-        """
-        Get the latest patch on an existing version by name in the application package.
-        Executes 'show versions like ... in application package' query and returns
-        the latest patch in the version as a single row, if one exists. Otherwise,
-        returns None.
-        """
-        with self.use_role(self.package_role):
-            try:
-                query = f"show versions like {identifier_to_show_like_pattern(version)} in application package {self.package_name}"
-                cursor = self._execute_query(query, cursor_class=DictCursor)
-
-                if cursor.rowcount is None:
-                    raise SnowflakeSQLExecutionError(query)
-
-                matching_rows = find_all_rows(
-                    cursor, lambda row: row[VERSION_COL] == unquote_identifier(version)
-                )
-
-                if not matching_rows:
-                    return None
-
-                return max(matching_rows, key=lambda row: row[PATCH_COL])
-
-            except ProgrammingError as err:
-                if err.msg.__contains__("does not exist or not authorized"):
-                    raise ApplicationPackageDoesNotExistError(self.package_name)
-                else:
-                    generic_sql_error_handler(err=err, role=self.package_role)
-                    return None
+        return ApplicationEntity.get_existing_version_info(
+            version=version,
+            package_name=self.package_name,
+            package_role=self.package_role,
+        )
 
     def drop_application_before_upgrade(
         self, policy: PolicyBase, is_interactive: bool, cascade: bool = False
@@ -249,90 +123,26 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
         install_method: SameAccountInstallMethod,
         is_interactive: bool = False,
     ):
-        with self.use_role(self.app_role):
-
-            # 1. Need to use a warehouse to create an application object
-            with self.use_warehouse(self.application_warehouse):
-
-                # 2. Check for an existing application by the same name
-                show_app_row = self.get_existing_app_info()
-
-                # 3. If existing application is found, perform a few validations and upgrade the application object.
-                if show_app_row:
-
-                    install_method.ensure_app_usable(self._na_project, show_app_row)
-
-                    # If all the above checks are in order, proceed to upgrade
-                    try:
-                        cc.step(
-                            f"Upgrading existing application object {self.app_name}."
-                        )
-                        using_clause = install_method.using_clause(self._na_project)
-                        upgrade_cursor = self._execute_query(
-                            f"alter application {self.app_name} upgrade {using_clause}",
-                        )
-                        print_messages(upgrade_cursor)
-
-                        if install_method.is_dev_mode:
-                            # if debug_mode is present (controlled), ensure it is up-to-date
-                            if self.debug_mode is not None:
-                                self._execute_query(
-                                    f"alter application {self.app_name} set debug_mode = {self.debug_mode}"
-                                )
-
-                        # hooks always executed after a create or upgrade
-                        self.execute_app_post_deploy_hooks()
-                        return
-
-                    except ProgrammingError as err:
-                        if err.errno not in UPGRADE_RESTRICTION_CODES:
-                            generic_sql_error_handler(err=err)
-                        else:  # The existing application object was created from a different process.
-                            cc.warning(err.msg)
-                            self.drop_application_before_upgrade(policy, is_interactive)
-
-                # 4. With no (more) existing application objects, create an application object using the release directives
-                cc.step(f"Creating new application object {self.app_name} in account.")
-
-                if self.app_role != self.package_role:
-                    with self.use_role(self.package_role):
-                        self._execute_query(
-                            f"grant install, develop on application package {self.package_name} to role {self.app_role}"
-                        )
-                        self._execute_query(
-                            f"grant usage on schema {self.package_name}.{self.stage_schema} to role {self.app_role}"
-                        )
-                        self._execute_query(
-                            f"grant read on stage {self.stage_fqn} to role {self.app_role}"
-                        )
-
-                try:
-                    # by default, applications are created in debug mode when possible;
-                    # this can be overridden in the project definition
-                    debug_mode_clause = ""
-                    if install_method.is_dev_mode:
-                        initial_debug_mode = (
-                            self.debug_mode if self.debug_mode is not None else True
-                        )
-                        debug_mode_clause = f"debug_mode = {initial_debug_mode}"
-
-                    using_clause = install_method.using_clause(self._na_project)
-                    create_cursor = self._execute_query(
-                        dedent(
-                            f"""\
-                        create application {self.app_name}
-                            from application package {self.package_name} {using_clause} {debug_mode_clause}
-                            comment = {SPECIAL_COMMENT}
-                        """
-                        ),
-                    )
-                    print_messages(create_cursor)
-
-                    # hooks always executed after a create or upgrade
-                    self.execute_app_post_deploy_hooks()
-
-                except ProgrammingError as err:
-                    generic_sql_error_handler(err)
+        def drop_app():
+            self.drop_application_before_upgrade(policy, is_interactive)
+
+        return ApplicationEntity.create_or_upgrade_app(
+            console=cc,
+            project_root=self.project_root,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            app_name=self.app_name,
+            app_role=self.app_role,
+            app_warehouse=self.application_warehouse,
+            stage_schema=self.stage_schema,
+            stage_fqn=self.stage_fqn,
+            debug_mode=self.debug_mode,
+            policy=policy,
+            install_method=install_method,
+            is_interactive=is_interactive,
+            post_deploy_hooks=self.app_post_deploy_hooks,
+            drop_application_before_upgrade=drop_app,
+        )
 
     def process(
         self,
@@ -346,46 +156,32 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
         *args,
         **kwargs,
     ):
-        """
-        Create or upgrade the application object using the given strategy
-        (unversioned dev, versioned dev, or same-account release directive).
-        """
-
-        # same-account release directive
-        if from_release_directive:
-            self.create_or_upgrade_app(
-                policy=policy,
-                is_interactive=is_interactive,
-                install_method=SameAccountInstallMethod.release_directive(),
+        def deploy_package():
+            self.deploy(
+                bundle_map=bundle_map, prune=True, recursive=True, validate=validate
             )
-            return
 
-        # versioned dev
-        if version:
-            try:
-                version_exists = self.get_existing_version_info(version)
-                if not version_exists:
-                    raise UsageError(
-                        f"Application package {self.package_name} does not have any version {version} defined. Use 'snow app version create' to define a version in the application package first."
-                    )
-            except ApplicationPackageDoesNotExistError as app_err:
-                raise UsageError(
-                    f"Application package {self.package_name} does not exist. Use 'snow app version create' to first create an application package and then define a version in it."
-                )
-
-            self.create_or_upgrade_app(
-                policy=policy,
-                install_method=SameAccountInstallMethod.versioned_dev(version, patch),
-                is_interactive=is_interactive,
-            )
-            return
-
-        # unversioned dev
-        self.deploy(
-            bundle_map=bundle_map, prune=True, recursive=True, validate=validate
-        )
-        self.create_or_upgrade_app(
-            policy=policy,
+        def drop_app():
+            self.drop_application_before_upgrade(policy, is_interactive)
+
+        ApplicationEntity.deploy(
+            console=cc,
+            project_root=self.project_root,
+            app_name=self.app_name,
+            app_role=self.app_role,
+            app_warehouse=self.application_warehouse,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            stage_schema=self.stage_schema,
+            stage_fqn=self.stage_fqn,
+            debug_mode=self.debug_mode,
+            validate=validate,
+            from_release_directive=from_release_directive,
             is_interactive=is_interactive,
-            install_method=SameAccountInstallMethod.unversioned_dev(),
+            policy=policy,
+            version=version,
+            patch=patch,
+            post_deploy_hooks=self.app_post_deploy_hooks,
+            deploy_package=deploy_package,
+            drop_application_before_upgrade=drop_app,
         )

snowflake/cli/_plugins/nativeapp/same_account_install_method.py

@@ -0,0 +1,74 @@
+from typing import Optional
+
+from snowflake.cli._plugins.nativeapp.constants import (
+    ALLOWED_SPECIAL_COMMENTS,
+    COMMENT_COL,
+)
+from snowflake.cli._plugins.nativeapp.exceptions import (
+    ApplicationCreatedExternallyError,
+)
+
+# from snowflake.cli._plugins.nativeapp.project_model import NativeAppProjectModel
+from snowflake.cli._plugins.stage.manager import StageManager
+from snowflake.cli.api.entities.utils import ensure_correct_owner
+
+
+class SameAccountInstallMethod:
+    _requires_created_by_cli: bool
+    _from_release_directive: bool
+    version: Optional[str]
+    patch: Optional[int]
+
+    def __init__(
+        self,
+        requires_created_by_cli: bool,
+        version: Optional[str] = None,
+        patch: Optional[int] = None,
+        from_release_directive: bool = False,
+    ):
+        self._requires_created_by_cli = requires_created_by_cli
+        self.version = version
+        self.patch = patch
+        self._from_release_directive = from_release_directive
+
+    @classmethod
+    def unversioned_dev(cls):
+        """aka. stage dev aka loose files"""
+        return cls(True)
+
+    @classmethod
+    def versioned_dev(cls, version: str, patch: Optional[int] = None):
+        return cls(False, version, patch)
+
+    @classmethod
+    def release_directive(cls):
+        return cls(False, from_release_directive=True)
+
+    @property
+    def is_dev_mode(self) -> bool:
+        return not self._from_release_directive
+
+    def using_clause(
+        self,
+        stage_fqn: str,
+    ) -> str:
+        if self._from_release_directive:
+            return ""
+
+        if self.version:
+            patch_clause = f"patch {self.patch}" if self.patch else ""
+            return f"using version {self.version} {patch_clause}"
+
+        stage_name = StageManager.quote_stage_name(stage_fqn)
+        return f"using {stage_name}"
+
+    def ensure_app_usable(self, app_name: str, app_role: str, show_app_row: dict):
+        """Raise an exception if we cannot proceed with install given the pre-existing application object"""
+
+        if self._requires_created_by_cli:
+            if show_app_row[COMMENT_COL] not in ALLOWED_SPECIAL_COMMENTS:
+                # this application object was not created by this tooling
+                raise ApplicationCreatedExternallyError(app_name)
+
+        # expected owner
+        ensure_correct_owner(row=show_app_row, role=app_role, obj_name=app_name)