snowflake-cli-labs 2.5.0rc3__py3-none-any.whl → 2.6.0rc0__py3-none-any.whl

snowflake/cli/plugins/nativeapp/run_processor.py

@@ -28,10 +28,13 @@ from snowflake.cli.api.project.util import (
     unquote_identifier,
 )
 from snowflake.cli.api.utils.cursor import find_all_rows
+from snowflake.cli.api.utils.rendering import snowflake_sql_jinja_render
 from snowflake.cli.plugins.nativeapp.artifacts import BundleMap
 from snowflake.cli.plugins.nativeapp.constants import (
     ALLOWED_SPECIAL_COMMENTS,
     COMMENT_COL,
+    ERROR_MESSAGE_093079,
+    ERROR_MESSAGE_093128,
     LOOSE_FILES_MAGIC_VERSION,
     PATCH_COL,
     SPECIAL_COMMENT,
@@ -48,99 +51,117 @@ from snowflake.cli.plugins.nativeapp.manager import (
     generic_sql_error_handler,
 )
 from snowflake.cli.plugins.nativeapp.policy import PolicyBase
-from snowflake.cli.plugins.stage.diff import DiffResult
+from snowflake.cli.plugins.nativeapp.project_model import (
+    NativeAppProjectModel,
+)
 from snowflake.cli.plugins.stage.manager import StageManager
 from snowflake.connector import ProgrammingError
 from snowflake.connector.cursor import DictCursor, SnowflakeCursor
 
-UPGRADE_RESTRICTION_CODES = {93044, 93055, 93045, 93046}
+# Reasons why an `alter application ... upgrade` might fail
+UPGRADE_RESTRICTION_CODES = {
+    93044,  # Cannot upgrade dev mode application from loose stage files to version
+    93045,  # Cannot upgrade dev mode application from version to loose stage files
+    93046,  # Operation only permitted on dev mode application
+    93055,  # Operation not supported on dev mode application
+    93079,  # App package access lost
+}
 
 
-class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
-    def __init__(self, project_definition: NativeApp, project_root: Path):
-        super().__init__(project_definition, project_root)
+class SameAccountInstallMethod:
+    _requires_created_by_cli: bool
+    _from_release_directive: bool
+    version: Optional[str]
+    patch: Optional[int]
 
-    def _create_dev_app(self, diff: DiffResult) -> None:
-        """
-        (Re-)creates the application object with our up-to-date stage.
-        """
-        with self.use_role(self.app_role):
+    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
 
-            # 1. Need to use a warehouse to create an application object
-            try:
-                if self.application_warehouse:
-                    self._execute_query(f"use warehouse {self.application_warehouse}")
-            except ProgrammingError as err:
-                generic_sql_error_handler(
-                    err=err, role=self.app_role, warehouse=self.application_warehouse
-                )
+    @classmethod
+    def unversioned_dev(cls):
+        """aka. stage dev aka loose files"""
+        return cls(True)
 
-            # 2. Check for an existing application object by the same name
-            show_app_row = self.get_existing_app_info()
+    @classmethod
+    def versioned_dev(cls, version: str, patch: Optional[int] = None):
+        return cls(False, version, patch)
 
-            # 3. If existing application object is found, perform a few validations and upgrade the application object.
-            if show_app_row:
+    @classmethod
+    def release_directive(cls):
+        return cls(False, from_release_directive=True)
 
-                # Check if not created by Snowflake CLI or not created using "files on a named stage" / stage dev mode.
-                if show_app_row[COMMENT_COL] not in ALLOWED_SPECIAL_COMMENTS or (
-                    show_app_row[VERSION_COL] != LOOSE_FILES_MAGIC_VERSION
-                ):
-                    raise ApplicationAlreadyExistsError(self.app_name)
+    @property
+    def is_dev_mode(self) -> bool:
+        return not self._from_release_directive
 
-                # Check for the right owner
-                ensure_correct_owner(
-                    row=show_app_row, role=self.app_role, obj_name=self.app_name
-                )
+    def using_clause(self, app: NativeAppProjectModel) -> str:
+        if self._from_release_directive:
+            return ""
 
-                # If all the above checks are in order, proceed to upgrade
-                try:
-                    cc.step(f"Upgrading existing application object {self.app_name}.")
-                    self._execute_query(
-                        f"alter application {self.app_name} upgrade using @{self.stage_fqn}"
-                    )
+        if self.version:
+            patch_clause = f"patch {self.patch}" if self.patch else ""
+            return f"using version {self.version} {patch_clause}"
 
-                    # ensure debug_mode is up-to-date
-                    self._execute_query(
-                        f"alter application {self.app_name} set debug_mode = {self.debug_mode}"
-                    )
+        stage_name = StageManager.quote_stage_name(app.stage_fqn)
+        return f"using {stage_name}"
 
-                    return
+    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"""
 
-                except ProgrammingError as err:
-                    generic_sql_error_handler(err)
+        if self._requires_created_by_cli:
+            if show_app_row[COMMENT_COL] not in ALLOWED_SPECIAL_COMMENTS or (
+                show_app_row[VERSION_COL] != LOOSE_FILES_MAGIC_VERSION
+            ):
+                # this application object was not created by this tooling
+                raise ApplicationAlreadyExistsError(app.app_name)
 
-            # 4. If no existing application object is found, create an application object using "files on a named stage" / stage dev mode.
-            cc.step(f"Creating new application {self.app_name} in account.")
+        # expected owner
+        ensure_correct_owner(row=show_app_row, role=app.app_role, obj_name=app.app_name)
 
-            if self.app_role != self.package_role:
-                with self.use_role(new_role=self.package_role):
-                    self._execute_queries(
-                        dedent(
-                            f"""\
-                        grant install, develop on application package {self.package_name} to role {self.app_role};
-                        grant usage on schema {self.package_name}.{self.stage_schema} to role {self.app_role};
-                        grant read on stage {self.stage_fqn} to role {self.app_role};
-                        """
-                        )
-                    )
 
-            stage_name = StageManager.quote_stage_name(self.stage_fqn)
+class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
+    def __init__(self, project_definition: NativeApp, project_root: Path):
+        super().__init__(project_definition, project_root)
 
+    def _execute_sql_script(self, sql_script_path):
+        """
+        Executing the SQL script in the provided file path after expanding template variables.
+        "use warehouse" and "use database" will be executed first if they are set in definition file or in the current connection.
+        """
+        with open(sql_script_path) as f:
+            sql_script = f.read()
             try:
-                self._execute_query(
-                    dedent(
-                        f"""\
-                    create application {self.app_name}
-                        from application package {self.package_name}
-                        using {stage_name}
-                        debug_mode = {self.debug_mode}
-                        comment = {SPECIAL_COMMENT}
-                    """
-                    )
-                )
+                if self.application_warehouse:
+                    self._execute_query(f"use warehouse {self.application_warehouse}")
+                if self._conn.database:
+                    self._execute_query(f"use database {self._conn.database}")
+                sql_script = snowflake_sql_jinja_render(content=sql_script)
+                self._execute_queries(sql_script)
             except ProgrammingError as err:
                 generic_sql_error_handler(err)
 
+    def _execute_post_deploy_hooks(self):
+        post_deploy_script_hooks = self.app_post_deploy_hooks
+        if post_deploy_script_hooks:
+            with cc.phase("Executing application post-deploy actions"):
+                for hook in post_deploy_script_hooks:
+                    if hook.sql_script:
+                        cc.step(f"Executing SQL script: {hook.sql_script}")
+                        self._execute_sql_script(hook.sql_script)
+                    else:
+                        raise ValueError(
+                            f"Unsupported application post-deploy hook type: {hook}"
+                        )
+
     def get_all_existing_versions(self) -> SnowflakeCursor:
         """
         Get all existing versions, if defined, for an application package.
@@ -186,11 +207,31 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
                     generic_sql_error_handler(err=err, role=self.package_role)
                     return None
 
-    def drop_application_before_upgrade(self, policy: PolicyBase, is_interactive: bool):
+    def drop_application_before_upgrade(
+        self, policy: PolicyBase, is_interactive: bool, cascade: bool = False
+    ):
         """
         This method will attempt to drop an application object if a previous upgrade fails.
         """
-        user_prompt = "Do you want the Snowflake CLI to drop the existing application object and recreate it?"
+        if cascade:
+            try:
+                if application_objects := self.get_objects_owned_by_application():
+                    application_objects_str = self._application_objects_to_str(
+                        application_objects
+                    )
+                    cc.message(
+                        f"The following objects are owned by application {self.app_name} and need to be dropped:\n{application_objects_str}"
+                    )
+            except ProgrammingError as err:
+                if err.errno != 93079 and ERROR_MESSAGE_093079 not in err.msg:
+                    generic_sql_error_handler(err)
+                cc.warning(
+                    "The application owns other objects but they could not be determined."
+                )
+            user_prompt = "Do you want the Snowflake CLI to drop these objects, then drop the existing application object and recreate it?"
+        else:
+            user_prompt = "Do you want the Snowflake CLI to drop the existing application object and recreate it?"
+
         if not policy.should_proceed(user_prompt):
             if is_interactive:
                 cc.message("Not upgrading the application object.")
@@ -201,21 +242,23 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
                 )
                 raise typer.Exit(1)
         try:
-            self._execute_query(f"drop application {self.app_name}")
+            cascade_sql = " cascade" if cascade else ""
+            self._execute_query(f"drop application {self.app_name}{cascade_sql}")
         except ProgrammingError as err:
-            generic_sql_error_handler(err)
+            if (err.errno == 93128 or ERROR_MESSAGE_093128 in err.msg) and not cascade:
+                # We need to cascade the deletion, let's try again (only if we didn't try with cascade already)
+                return self.drop_application_before_upgrade(
+                    policy, is_interactive, cascade=True
+                )
+            else:
+                generic_sql_error_handler(err)
 
-    def upgrade_app(
+    def create_or_upgrade_app(
         self,
         policy: PolicyBase,
-        is_interactive: bool,
-        version: Optional[str] = None,
-        patch: Optional[int] = None,
+        install_method: SameAccountInstallMethod,
+        is_interactive: bool = False,
     ):
-
-        patch_clause = f"patch {patch}" if patch else ""
-        using_clause = f"using version {version} {patch_clause}" if version else ""
-
         with self.use_role(self.app_role):
 
             # 1. Need to use a warehouse to create an application object
@@ -233,23 +276,25 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
             # 3. If existing application is found, perform a few validations and upgrade the application object.
             if show_app_row:
 
-                # We skip comment check here, because prod/pre-existing application objects may not be created by the Snowflake CLI.
-                # Check for the right owner
-                ensure_correct_owner(
-                    row=show_app_row, role=self.app_role, obj_name=self.app_name
-                )
+                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)
                     self._execute_query(
                         f"alter application {self.app_name} upgrade {using_clause}"
                     )
 
-                    # ensure debug_mode is up-to-date
-                    if using_clause:
-                        self._execute_query(
-                            f"alter application {self.app_name} set debug_mode = {self.debug_mode}"
-                        )
+                    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_post_deploy_hooks()
                     return
 
                 except ProgrammingError as err:
@@ -263,31 +308,41 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
             cc.step(f"Creating new application object {self.app_name} in account.")
 
             if self.app_role != self.package_role:
-                with self.use_role(new_role=self.package_role):
+                with self.use_role(self.package_role):
                     self._execute_query(
-                        f"grant install on application package {self.package_name} to role {self.app_role}"
+                        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}"
                     )
-                    if version:
-                        self._execute_query(
-                            f"grant develop on application package {self.package_name} 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)
                 self._execute_query(
                     dedent(
                         f"""\
                     create application {self.app_name}
-                        from application package {self.package_name} {using_clause}
+                        from application package {self.package_name} {using_clause} {debug_mode_clause}
                         comment = {SPECIAL_COMMENT}
                     """
                     )
                 )
 
-                # ensure debug_mode is up-to-date
-                if using_clause:
-                    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_post_deploy_hooks()
+
             except ProgrammingError as err:
                 generic_sql_error_handler(err)
 
@@ -303,12 +358,21 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
         *args,
         **kwargs,
     ):
-        """app run process"""
+        """
+        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.upgrade_app(policy=policy, is_interactive=is_interactive)
+            self.create_or_upgrade_app(
+                policy=policy,
+                is_interactive=is_interactive,
+                install_method=SameAccountInstallMethod.release_directive(),
+            )
             return
 
+        # versioned dev
         if version:
             try:
                 version_exists = self.get_existing_version_info(version)
@@ -321,15 +385,19 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
                     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.upgrade_app(
+            self.create_or_upgrade_app(
                 policy=policy,
-                version=version,
-                patch=patch,
+                install_method=SameAccountInstallMethod.versioned_dev(version, patch),
                 is_interactive=is_interactive,
             )
             return
 
-        diff = self.deploy(
+        # unversioned dev
+        self.deploy(
             bundle_map=bundle_map, prune=True, recursive=True, validate=validate
         )
-        self._create_dev_app(diff)
+        self.create_or_upgrade_app(
+            policy=policy,
+            is_interactive=is_interactive,
+            install_method=SameAccountInstallMethod.unversioned_dev(),
+        )

snowflake/cli/plugins/nativeapp/teardown_processor.py

@@ -28,11 +28,11 @@ from snowflake.cli.plugins.nativeapp.constants import (
     INTERNAL_DISTRIBUTION,
     OWNER_COL,
 )
+from snowflake.cli.plugins.nativeapp.errno import APPLICATION_NO_LONGER_AVAILABLE
 from snowflake.cli.plugins.nativeapp.exceptions import (
     CouldNotDropApplicationPackageWithVersions,
 )
 from snowflake.cli.plugins.nativeapp.manager import (
-    ApplicationOwnedObject,
     NativeAppCommandProcessor,
     NativeAppManager,
     ensure_correct_owner,
@@ -40,6 +40,7 @@ from snowflake.cli.plugins.nativeapp.manager import (
 from snowflake.cli.plugins.nativeapp.utils import (
     needs_confirmation,
 )
+from snowflake.connector import ProgrammingError
 from snowflake.connector.cursor import DictCursor
 
 
@@ -65,20 +66,6 @@ class NativeAppTeardownProcessor(NativeAppManager, NativeAppCommandProcessor):
 
             cc.message(f"Dropped {object_type} {object_name} successfully.")
 
-    def _application_objects_to_str(
-        self, application_objects: 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(
-            [f"({obj['type']}) {obj['name']}" for obj in application_objects]
-        )
-
     def drop_application(
         self, auto_yes: bool, interactive: bool = False, cascade: Optional[bool] = None
     ):
@@ -88,7 +75,7 @@ class NativeAppTeardownProcessor(NativeAppManager, NativeAppCommandProcessor):
 
         needs_confirm = True
 
-        # 1. If existing application package is not found, exit gracefully
+        # 1. If existing application is not found, exit gracefully
         show_obj_row = self.get_existing_app_info()
         if show_obj_row is None:
             cc.warning(
@@ -103,64 +90,102 @@ class NativeAppTeardownProcessor(NativeAppManager, NativeAppCommandProcessor):
 
         # 3. Check if created by the Snowflake CLI
         row_comment = show_obj_row[COMMENT_COL]
-        if row_comment in ALLOWED_SPECIAL_COMMENTS:
-            # No confirmation needed before dropping
-            needs_confirm = False
-        else:
-            if needs_confirmation(needs_confirm, auto_yes):
-                should_drop_object = typer.confirm(
-                    dedent(
-                        f"""\
-                            Application object {self.app_name} was not created by Snowflake CLI.
-                            Application object details:
-                            Name: {self.app_name}
-                            Created on: {show_obj_row["created_on"]}
-                            Source: {show_obj_row["source"]}
-                            Owner: {show_obj_row[OWNER_COL]}
-                            Comment: {show_obj_row[COMMENT_COL]}
-                            Version: {show_obj_row["version"]}
-                            Patch: {show_obj_row["patch"]}
-                            Are you sure you want to drop it?
-                        """
-                    )
+        if row_comment not in ALLOWED_SPECIAL_COMMENTS and needs_confirmation(
+            needs_confirm, auto_yes
+        ):
+            should_drop_object = typer.confirm(
+                dedent(
+                    f"""\
+                        Application object {self.app_name} was not created by Snowflake CLI.
+                        Application object details:
+                        Name: {self.app_name}
+                        Created on: {show_obj_row["created_on"]}
+                        Source: {show_obj_row["source"]}
+                        Owner: {show_obj_row[OWNER_COL]}
+                        Comment: {show_obj_row[COMMENT_COL]}
+                        Version: {show_obj_row["version"]}
+                        Patch: {show_obj_row["patch"]}
+                        Are you sure you want to drop it?
+                    """
                 )
-                if not should_drop_object:
-                    cc.message(f"Did not drop application object {self.app_name}.")
-                    return  # The user desires to keep the app, therefore exit gracefully
+            )
+            if not should_drop_object:
+                cc.message(f"Did not drop application object {self.app_name}.")
+                # The user desires to keep the app, therefore we can't proceed since it would
+                # leave behind an orphan app when we get to dropping the package
+                raise typer.Abort()
 
         # 4. Check for application objects owned by the application
-        application_objects = self.get_objects_owned_by_application()
-        if len(application_objects) > 0:
-            application_objects_str = self._application_objects_to_str(
-                application_objects
+        # This query will fail if the application package has already been dropped, so handle this case gracefully
+        has_objects_to_drop = False
+        message_prefix = ""
+        cascade_true_message = ""
+        cascade_false_message = ""
+        interactive_prompt = ""
+        non_interactive_abort = ""
+        try:
+            if application_objects := self.get_objects_owned_by_application():
+                has_objects_to_drop = True
+                message_prefix = (
+                    f"The following objects are owned by application {self.app_name}"
+                )
+                cascade_true_message = f"{message_prefix} and will be dropped:"
+                cascade_false_message = f"{message_prefix} and will NOT be dropped:"
+                interactive_prompt = "Would you like to drop these objects in addition to the application? [y/n/ABORT]"
+                non_interactive_abort = "Re-run teardown again with --cascade or --no-cascade to specify whether these objects should be dropped along with the application"
+        except ProgrammingError as e:
+            if e.errno != APPLICATION_NO_LONGER_AVAILABLE:
+                raise
+            application_objects = []
+            message_prefix = f"Could not determine which objects are owned by application {self.app_name}"
+            has_objects_to_drop = True  # potentially, but we don't know what they are
+            cascade_true_message = (
+                f"{message_prefix}, an unknown number of objects will be dropped."
             )
+            cascade_false_message = f"{message_prefix}, they will NOT be dropped."
+            interactive_prompt = f"Would you like to drop an unknown set of objects in addition to the application? [y/n/ABORT]"
+            non_interactive_abort = f"Re-run teardown again with --cascade or --no-cascade to specify whether any objects should be dropped along with the application."
+
+        if has_objects_to_drop:
             if cascade is True:
-                cc.message(
-                    f"The following objects are owned by application {self.app_name} and will be dropped:\n{application_objects_str}"
-                )
+                # If the user explicitly passed the --cascade flag
+                cc.message(cascade_true_message)
+                with cc.indented():
+                    for obj in application_objects:
+                        cc.message(self._application_object_to_str(obj))
             elif cascade is False:
-                cc.message(
-                    f"The following objects are owned by application {self.app_name}:\n{application_objects_str}"
-                )
+                # If the user explicitly passed the --no-cascade flag
+                cc.message(cascade_false_message)
+                with cc.indented():
+                    for obj in application_objects:
+                        cc.message(self._application_object_to_str(obj))
             elif interactive:
-                if interactive:
-                    user_response = typer.prompt(
-                        f"The following objects are owned by application {self.app_name}:\n{application_objects_str}\n\nWould you like to drop these objects in addition to the application? [y/n/ABORT]",
-                        show_default=False,
-                        default="ABORT",
-                    )
-                    if user_response in ["y", "yes", "Y", "Yes", "YES"]:
-                        cascade = True
-                    elif user_response in ["n", "no", "N", "No", "NO"]:
-                        cascade = False
-                    else:
-                        raise typer.Abort()
+                # If the user didn't pass any cascade flag and the session is interactive
+                cc.message(message_prefix)
+                with cc.indented():
+                    for obj in application_objects:
+                        cc.message(self._application_object_to_str(obj))
+                user_response = typer.prompt(
+                    interactive_prompt,
+                    show_default=False,
+                    default="ABORT",
+                ).lower()
+                if user_response in ["y", "yes"]:
+                    cascade = True
+                elif user_response in ["n", "no"]:
+                    cascade = False
+                else:
+                    raise typer.Abort()
             else:
-                cc.message(
-                    f"The following application objects are owned by application {self.app_name}:\n{application_objects_str}\n\nRe-run teardown again with --cascade or --no-cascade to specify whether these objects should be dropped along with the application."
-                )
+                # Else abort since we don't know what to do and can't ask the user
+                cc.message(message_prefix)
+                with cc.indented():
+                    for obj in application_objects:
+                        cc.message(self._application_object_to_str(obj))
+                cc.message(non_interactive_abort)
                 raise typer.Abort()
         elif cascade is None:
+            # If there's nothing to drop, set cascade to an explicit False value
             cascade = False
 
         # 5. All validations have passed, drop object

snowflake/cli/plugins/nativeapp/utils.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 import os
 from pathlib import Path
 from sys import stdin, stdout
-from typing import List, Optional, Union
+from typing import Iterable, Optional, Union
 
 from click import ClickException
 
@@ -85,7 +85,7 @@ def shallow_git_clone(url: Union[str, os.PathLike], to_path: Union[str, os.PathL
     return repo
 
 
-def verify_no_directories(paths_to_sync: List[Path]):
+def verify_no_directories(paths_to_sync: Iterable[Path]):
     for path in paths_to_sync:
         if path.is_dir():
             raise ClickException(

snowflake/cli/plugins/nativeapp/version/commands.py

@@ -89,7 +89,7 @@ def create(
         git_policy = AllowAlwaysPolicy()
 
     processor = NativeAppVersionCreateProcessor(
-        project_definition=cli_context.project_definition,
+        project_definition=cli_context.project_definition.native_app,
         project_root=cli_context.project_root,
     )
 
@@ -115,7 +115,7 @@ def version_list(
     Lists all versions defined in an application package.
     """
     processor = NativeAppRunProcessor(
-        project_definition=cli_context.project_definition,
+        project_definition=cli_context.project_definition.native_app,
         project_root=cli_context.project_root,
     )
     cursor = processor.get_all_existing_versions()
@@ -147,7 +147,7 @@ def drop(
         policy = DenyAlwaysPolicy()
 
     processor = NativeAppVersionDropProcessor(
-        project_definition=cli_context.project_definition,
+        project_definition=cli_context.project_definition.native_app,
         project_root=cli_context.project_root,
     )
     processor.process(version, policy, is_interactive)