snowflake-cli-labs 2.6.0rc0__py3-none-any.whl → 2.7.0__py3-none-any.whl

snowflake/cli/plugins/nativeapp/commands.py

@@ -32,7 +32,9 @@ from snowflake.cli.api.output.types import (
     CommandResult,
     MessageResult,
     ObjectResult,
+    StreamResult,
 )
+from snowflake.cli.api.project.project_verification import assert_project_type
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.plugins.nativeapp.common_flags import (
     ForceOption,
@@ -57,7 +59,15 @@ from snowflake.cli.plugins.nativeapp.utils import (
     get_first_paragraph_from_markdown_file,
     shallow_git_clone,
 )
+from snowflake.cli.plugins.nativeapp.v2_conversions.v2_to_v1_decorator import (
+    nativeapp_definition_v2_to_v1,
+)
 from snowflake.cli.plugins.nativeapp.version.commands import app as versions_app
+from snowflake.cli.plugins.stage.diff import (
+    DiffResult,
+    compute_stage_diff,
+    print_diff_to_console,
+)
 
 app = SnowTyperFactory(
     name="app",
@@ -145,13 +155,17 @@ def app_list_templates(**options) -> CommandResult:
 
 
 @app.command("bundle")
-@with_project_definition("native_app")
+@with_project_definition()
+@nativeapp_definition_v2_to_v1
 def app_bundle(
     **options,
 ) -> CommandResult:
     """
     Prepares a local folder with configured app artifacts.
     """
+
+    assert_project_type("native_app")
+
     manager = NativeAppManager(
         project_definition=cli_context.project_definition.native_app,
         project_root=cli_context.project_root,
@@ -160,8 +174,35 @@ def app_bundle(
     return MessageResult(f"Bundle generated at {manager.deploy_root}")
 
 
+@app.command("diff", requires_connection=True, hidden=True)
+@with_project_definition()
+@nativeapp_definition_v2_to_v1
+def app_diff(
+    **options,
+) -> CommandResult:
+    """
+    Performs a diff between the app's source stage and the local deploy root.
+    """
+    assert_project_type("native_app")
+
+    manager = NativeAppManager(
+        project_definition=cli_context.project_definition.native_app,
+        project_root=cli_context.project_root,
+    )
+    bundle_map = manager.build_bundle()
+    diff: DiffResult = compute_stage_diff(
+        local_root=Path(manager.deploy_root), stage_fqn=manager.stage_fqn
+    )
+    if cli_context.output_format == OutputFormat.JSON:
+        return ObjectResult(diff.to_dict())
+    else:
+        print_diff_to_console(diff, bundle_map)
+        return None  # don't print any output
+
+
 @app.command("run", requires_connection=True)
-@with_project_definition("native_app")
+@with_project_definition()
+@nativeapp_definition_v2_to_v1
 def app_run(
     version: Optional[str] = typer.Option(
         None,
@@ -191,6 +232,8 @@ def app_run(
     then creates or upgrades an application object from the application package.
     """
 
+    assert_project_type("native_app")
+
     is_interactive = False
     if force:
         policy = AllowAlwaysPolicy()
@@ -221,7 +264,8 @@ def app_run(
 
 
 @app.command("open", requires_connection=True)
-@with_project_definition("native_app")
+@with_project_definition()
+@nativeapp_definition_v2_to_v1
 def app_open(
     **options,
 ) -> CommandResult:
@@ -229,6 +273,9 @@ def app_open(
     Opens the Snowflake Native App inside of your browser,
     once it has been installed in your account.
     """
+
+    assert_project_type("native_app")
+
     manager = NativeAppManager(
         project_definition=cli_context.project_definition.native_app,
         project_root=cli_context.project_root,
@@ -243,7 +290,8 @@ def app_open(
 
 
 @app.command("teardown", requires_connection=True)
-@with_project_definition("native_app")
+@with_project_definition()
+@nativeapp_definition_v2_to_v1
 def app_teardown(
     force: Optional[bool] = ForceOption,
     cascade: Optional[bool] = typer.Option(
@@ -257,6 +305,9 @@ def app_teardown(
     """
     Attempts to drop both the application object and application package as defined in the project definition file.
     """
+
+    assert_project_type("native_app")
+
     processor = NativeAppTeardownProcessor(
         project_definition=cli_context.project_definition.native_app,
         project_root=cli_context.project_root,
@@ -266,7 +317,8 @@ def app_teardown(
 
 
 @app.command("deploy", requires_connection=True)
-@with_project_definition("native_app")
+@with_project_definition()
+@nativeapp_definition_v2_to_v1
 def app_deploy(
     prune: Optional[bool] = typer.Option(
         default=None,
@@ -296,6 +348,9 @@ def app_deploy(
     Creates an application package in your Snowflake account and syncs the local changes to the stage without creating or updating the application.
     Running this command with no arguments at all, as in `snow app deploy`, is a shorthand for `snow app deploy --prune --recursive`.
     """
+
+    assert_project_type("native_app")
+
     has_paths = paths is not None and len(paths) > 0
     if prune is None and recursive is None and not has_paths:
         prune = True
@@ -329,11 +384,15 @@ def app_deploy(
 
 
 @app.command("validate", requires_connection=True)
-@with_project_definition("native_app")
+@with_project_definition()
+@nativeapp_definition_v2_to_v1
 def app_validate(**options):
     """
     Validates a deployed Snowflake Native App's setup script.
     """
+
+    assert_project_type("native_app")
+
     manager = NativeAppManager(
         project_definition=cli_context.project_definition.native_app,
         project_root=cli_context.project_root,
@@ -343,3 +402,38 @@ def app_validate(**options):
 
     manager.validate(use_scratch_stage=True)
     return MessageResult("Snowflake Native App validation succeeded.")
+
+
+@app.command("events", hidden=True, requires_connection=True)
+@with_project_definition()
+@nativeapp_definition_v2_to_v1
+def app_events(**options):
+    """Fetches events for this app from the event table configured in Snowflake."""
+    assert_project_type("native_app")
+
+    manager = NativeAppManager(
+        project_definition=cli_context.project_definition.native_app,
+        project_root=cli_context.project_root,
+    )
+    events = manager.get_events()
+    if not events:
+        return MessageResult("No events found.")
+
+    def g():
+        for event in events:
+            yield EventResult(event)
+
+    return StreamResult(g())
+
+
+class EventResult(ObjectResult, MessageResult):
+    """ObjectResult that renders as a custom string when not printed as JSON."""
+
+    @property
+    def message(self):
+        e = self._element
+        return f"{e['TIMESTAMP']} {e['VALUE']}"
+
+    @property
+    def result(self):
+        return self._element

snowflake/cli/plugins/nativeapp/constants.py

@@ -25,9 +25,3 @@ PATCH_COL = "patch"
 
 INTERNAL_DISTRIBUTION = "internal"
 EXTERNAL_DISTRIBUTION = "external"
-
-ERROR_MESSAGE_2003 = "does not exist or not authorized"
-ERROR_MESSAGE_2043 = "Object does not exist, or operation cannot be performed."
-ERROR_MESSAGE_606 = "No active warehouse selected in the current session."
-ERROR_MESSAGE_093079 = "Application is no longer available for use"
-ERROR_MESSAGE_093128 = "The application owns one or more objects within the account"

snowflake/cli/plugins/nativeapp/exceptions.py

@@ -12,7 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from textwrap import dedent
+from typing import Optional
 
 import jinja2
 from click.exceptions import ClickException
@@ -36,12 +39,12 @@ class ApplicationPackageDoesNotExistError(ClickException):
         )
 
 
-class ApplicationAlreadyExistsError(ClickException):
+class ApplicationCreatedExternallyError(ClickException):
     """An application object not created by Snowflake CLI exists with the same name."""
 
     def __init__(self, name: str):
         super().__init__(
-            f'A application object "{name}" not created in development mode using files on a named stage already exists in the account.'
+            f'An application object "{name}" not created by Snowflake CLI already exists in the account.'
         )
 
 
@@ -54,18 +57,23 @@ class UnexpectedOwnerError(ClickException):
         )
 
 
-class MissingPackageScriptError(ClickException):
-    """A referenced package script was not found."""
+class MissingScriptError(ClickException):
+    """A referenced script was not found."""
 
     def __init__(self, relpath: str):
-        super().__init__(f'Package script "{relpath}" does not exist')
+        super().__init__(f'Script "{relpath}" does not exist')
 
 
-class InvalidPackageScriptError(ClickException):
-    """A referenced package script had syntax error(s)."""
+class InvalidScriptError(ClickException):
+    """A referenced script had syntax error(s)."""
 
-    def __init__(self, relpath: str, err: jinja2.TemplateError):
-        super().__init__(f'Package script "{relpath}" is not a valid jinja2 template')
+    def __init__(
+        self, relpath: str, err: jinja2.TemplateError, lineno: Optional[int] = None
+    ):
+        lineno_str = f":{lineno}" if lineno is not None else ""
+        super().__init__(
+            f'Script "{relpath}{lineno_str}" does not contain a valid template: {err.message}'
+        )
         self.err = err
 
 
@@ -79,14 +87,14 @@ class MissingSchemaError(ClickException):
 class CouldNotDropApplicationPackageWithVersions(ClickException):
     """Application package could not be dropped as it has versions associated with it."""
 
-    def __init__(self):
+    def __init__(self, additional_msg: str = ""):
         super().__init__(
             dedent(
                 f"""
             {self.__doc__}
-            Versions must be dropped first using “snow app version drop”.
+            {additional_msg}
             """
-            )
+            ).strip()
         )
 
 
@@ -95,3 +103,20 @@ class SetupScriptFailedValidation(ClickException):
 
     def __init__(self):
         super().__init__(self.__doc__)
+
+
+class NoEventTableForAccount(ClickException):
+    """No event table was found for this Snowflake account."""
+
+    INSTRUCTIONS = dedent(
+        """\
+        Ask your Snowflake administrator to set up an event table for your account by following the docs at
+        https://docs.snowflake.com/en/developer-guide/logging-tracing/event-table-setting-up.
+
+        If your account is configured to send events to an organization event account, create a new
+        connection to this account using `snow connection add` and re-run this command using the new connection.
+        More information on event accounts is available at https://docs.snowflake.com/en/developer-guide/native-apps/setting-up-logging-and-events#configure-an-account-to-store-shared-events."""
+    )
+
+    def __init__(self):
+        super().__init__(f"{self.__doc__}\n\n{self.INSTRUCTIONS}")

snowflake/cli/plugins/nativeapp/init.py

@@ -28,8 +28,8 @@ from snowflake.cli.api.project.util import (
     is_valid_unquoted_identifier,
     to_identifier,
 )
+from snowflake.cli.api.rendering.jinja import jinja_render_from_file
 from snowflake.cli.api.secure_path import SecurePath
-from snowflake.cli.api.utils.rendering import jinja_render_from_file
 from yaml import dump, safe_dump, safe_load
 
 log = logging.getLogger(__name__)

snowflake/cli/plugins/nativeapp/manager.py

@@ -17,14 +17,20 @@ from __future__ import annotations
 import json
 import os
 from abc import ABC, abstractmethod
+from contextlib import contextmanager
 from functools import cached_property
 from pathlib import Path
 from textwrap import dedent
-from typing import List, Optional, TypedDict
+from typing import Any, List, NoReturn, Optional, TypedDict
 
 import jinja2
 from click import ClickException
 from snowflake.cli.api.console import cli_console as cc
+from snowflake.cli.api.errno import (
+    DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED,
+    DOES_NOT_EXIST_OR_NOT_AUTHORIZED,
+    NO_WAREHOUSE_SELECTED_IN_SESSION,
+)
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
 from snowflake.cli.api.project.schemas.native_app.application import (
     ApplicationPostDeployHook,
@@ -48,9 +54,6 @@ from snowflake.cli.plugins.nativeapp.codegen.compiler import (
 from snowflake.cli.plugins.nativeapp.constants import (
     ALLOWED_SPECIAL_COMMENTS,
     COMMENT_COL,
-    ERROR_MESSAGE_606,
-    ERROR_MESSAGE_2003,
-    ERROR_MESSAGE_2043,
     INTERNAL_DISTRIBUTION,
     NAME_COL,
     OWNER_COL,
@@ -59,8 +62,9 @@ from snowflake.cli.plugins.nativeapp.constants import (
 from snowflake.cli.plugins.nativeapp.exceptions import (
     ApplicationPackageAlreadyExistsError,
     ApplicationPackageDoesNotExistError,
-    InvalidPackageScriptError,
-    MissingPackageScriptError,
+    InvalidScriptError,
+    MissingScriptError,
+    NoEventTableForAccount,
     SetupScriptFailedValidation,
     UnexpectedOwnerError,
 )
@@ -78,16 +82,16 @@ from snowflake.cli.plugins.stage.diff import (
     to_stage_path,
 )
 from snowflake.cli.plugins.stage.manager import StageManager
-from snowflake.connector import ProgrammingError
+from snowflake.connector import DictCursor, ProgrammingError
 
 ApplicationOwnedObject = TypedDict("ApplicationOwnedObject", {"name": str, "type": str})
 
 
 def generic_sql_error_handler(
     err: ProgrammingError, role: Optional[str] = None, warehouse: Optional[str] = None
-):
+) -> NoReturn:
     # Potential refactor: If moving away from Python 3.8 and 3.9 to >= 3.10, use match ... case
-    if err.errno == 2043 or err.msg.__contains__(ERROR_MESSAGE_2043):
+    if err.errno == DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED:
         raise ProgrammingError(
             msg=dedent(
                 f"""\
@@ -98,7 +102,7 @@ def generic_sql_error_handler(
             ),
             errno=err.errno,
         )
-    elif err.errno == 606 or err.msg.__contains__(ERROR_MESSAGE_606):
+    elif err.errno == NO_WAREHOUSE_SELECTED_IN_SESSION:
         raise ProgrammingError(
             msg=dedent(
                 f"""\
@@ -108,7 +112,7 @@ def generic_sql_error_handler(
             ),
             errno=err.errno,
         )
-    elif err.msg.__contains__("does not exist or not authorized"):
+    elif "does not exist or not authorized" in err.msg:
         raise ProgrammingError(
             msg=dedent(
                 f"""\
@@ -216,10 +220,40 @@ class NativeAppManager(SqlExecutionMixin):
     def package_warehouse(self) -> Optional[str]:
         return self.na_project.package_warehouse
 
+    @contextmanager
+    def use_package_warehouse(self):
+        if self.package_warehouse:
+            with self.use_warehouse(self.package_warehouse):
+                yield
+        else:
+            raise ClickException(
+                dedent(
+                    f"""\
+                Application package warehouse cannot be empty.
+                Please provide a value for it in your connection information or your project definition file.
+                """
+                )
+            )
+
     @property
     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.
+                """
+                )
+            )
+
     @property
     def project_identifier(self) -> str:
         return self.na_project.project_identifier
@@ -280,6 +314,12 @@ class NativeAppManager(SqlExecutionMixin):
             )
         )
 
+    @cached_property
+    def account_event_table(self) -> str:
+        query = "show parameters like 'event_table' in account"
+        results = self._execute_query(query, cursor_class=DictCursor)
+        return next((r["value"] for r in results if r["key"] == "EVENT_TABLE"), "")
+
     def verify_project_distribution(
         self, expected_distribution: Optional[str] = None
     ) -> bool:
@@ -482,7 +522,8 @@ class NativeAppManager(SqlExecutionMixin):
     def get_snowsight_url(self) -> str:
         """Returns the URL that can be used to visit this app via Snowsight."""
         name = identifier_for_url(self.app_name)
-        return make_snowsight_url(self._conn, f"/#/apps/application/{name}")
+        with self.use_application_warehouse():
+            return make_snowsight_url(self._conn, f"/#/apps/application/{name}")
 
     def create_app_package(self) -> None:
         """
@@ -527,6 +568,36 @@ class NativeAppManager(SqlExecutionMixin):
                 )
             )
 
+    def _expand_script_templates(
+        self, env: jinja2.Environment, jinja_context: dict[str, Any], scripts: List[str]
+    ) -> List[str]:
+        """
+        Input:
+        - env: Jinja2 environment
+        - jinja_context: a dictionary with the jinja context
+        - scripts: list of scripts that need to be expanded with Jinja
+        Returns:
+        - List of expanded scripts content.
+        Size of the return list is the same as the size of the input scripts list.
+        """
+        scripts_contents = []
+        for relpath in scripts:
+            try:
+                template = env.get_template(relpath)
+                result = template.render(**jinja_context)
+                scripts_contents.append(result)
+
+            except jinja2.TemplateNotFound as e:
+                raise MissingScriptError(e.name) from e
+
+            except jinja2.TemplateSyntaxError as e:
+                raise InvalidScriptError(e.name, e, e.lineno) from e
+
+            except jinja2.UndefinedError as e:
+                raise InvalidScriptError(relpath, e) from e
+
+        return scripts_contents
+
     def _apply_package_scripts(self) -> None:
         """
         Assuming the application package exists and we are using the correct role,
@@ -538,34 +609,20 @@ class NativeAppManager(SqlExecutionMixin):
             undefined=jinja2.StrictUndefined,
         )
 
-        queued_queries = []
-        for relpath in self.package_scripts:
-            try:
-                template = env.get_template(relpath)
-                result = template.render(dict(package_name=self.package_name))
-                queued_queries.append(result)
-
-            except jinja2.TemplateNotFound as e:
-                raise MissingPackageScriptError(e.name)
-
-            except jinja2.TemplateSyntaxError as e:
-                raise InvalidPackageScriptError(e.name, e)
-
-            except jinja2.UndefinedError as e:
-                raise InvalidPackageScriptError(relpath, e)
+        queued_queries = self._expand_script_templates(
+            env, dict(package_name=self.package_name), self.package_scripts
+        )
 
         # once we're sure all the templates expanded correctly, execute all of them
-        try:
-            if self.package_warehouse:
-                self._execute_query(f"use warehouse {self.package_warehouse}")
-
-            for i, queries in enumerate(queued_queries):
-                cc.step(f"Applying package script: {self.package_scripts[i]}")
-                self._execute_queries(queries)
-        except ProgrammingError as err:
-            generic_sql_error_handler(
-                err, role=self.package_role, warehouse=self.package_warehouse
-            )
+        with self.use_package_warehouse():
+            try:
+                for i, queries in enumerate(queued_queries):
+                    cc.step(f"Applying package script: {self.package_scripts[i]}")
+                    self._execute_queries(queries)
+            except ProgrammingError as err:
+                generic_sql_error_handler(
+                    err, role=self.package_role, warehouse=self.package_warehouse
+                )
 
     def deploy(
         self,
@@ -642,7 +699,7 @@ class NativeAppManager(SqlExecutionMixin):
                 f"call system$validate_native_app_setup('{prefixed_stage_fqn}')"
             )
         except ProgrammingError as err:
-            if err.errno == 2003 and ERROR_MESSAGE_2003 in err.msg:
+            if err.errno == DOES_NOT_EXIST_OR_NOT_AUTHORIZED:
                 raise ApplicationPackageDoesNotExistError(self.package_name)
             generic_sql_error_handler(err)
         else:
@@ -657,6 +714,24 @@ class NativeAppManager(SqlExecutionMixin):
                         f"drop stage if exists {self.scratch_stage_fqn}"
                     )
 
+    def get_events(self) -> list[dict]:
+        if not self.account_event_table:
+            raise NoEventTableForAccount()
+
+        # resource_attributes:"snow.database.name" uses the unquoted/uppercase app name
+        app_name = unquote_identifier(self.app_name)
+        query = dedent(
+            f"""\
+            select timestamp, value::varchar value
+            from {self.account_event_table}
+            where resource_attributes:"snow.database.name" = '{app_name}'
+            order by timestamp asc;"""
+        )
+        try:
+            return self._execute_query(query, cursor_class=DictCursor).fetchall()
+        except ProgrammingError as err:
+            generic_sql_error_handler(err)
+
 
 def _validation_item_to_str(item: dict[str, str | int]):
     s = item["message"]

snowflake/cli/plugins/nativeapp/project_model.py

@@ -105,16 +105,20 @@ class NativeAppProjectModel:
     @cached_property
     def package_warehouse(self) -> Optional[str]:
         if self.definition.package and self.definition.package.warehouse:
-            return self.definition.package.warehouse
+            return to_identifier(self.definition.package.warehouse)
         else:
-            return cli_context.connection.warehouse
+            if cli_context.connection.warehouse:
+                return to_identifier(cli_context.connection.warehouse)
+            return None
 
     @cached_property
     def application_warehouse(self) -> Optional[str]:
         if self.definition.application and self.definition.application.warehouse:
-            return self.definition.application.warehouse
+            return to_identifier(self.definition.application.warehouse)
         else:
-            return cli_context.connection.warehouse
+            if cli_context.connection.warehouse:
+                return to_identifier(cli_context.connection.warehouse)
+            return None
 
     @cached_property
     def project_identifier(self) -> str: