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

snowflake/cli/plugins/nativeapp/run_processor.py

@@ -18,30 +18,39 @@ from pathlib import Path
 from textwrap import dedent
 from typing import Optional
 
+import jinja2
 import typer
 from click import UsageError
+from snowflake.cli.api.cli_global_context import cli_context
 from snowflake.cli.api.console import cli_console as cc
+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.rendering.sql_templates import (
+    get_sql_cli_jinja_env,
+)
 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,
     VERSION_COL,
 )
 from snowflake.cli.plugins.nativeapp.exceptions import (
-    ApplicationAlreadyExistsError,
+    ApplicationCreatedExternallyError,
     ApplicationPackageDoesNotExistError,
 )
 from snowflake.cli.plugins.nativeapp.manager import (
@@ -60,11 +69,11 @@ from snowflake.connector.cursor import DictCursor, SnowflakeCursor
 
 # 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
+    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,
 }
 
 
@@ -118,11 +127,9 @@ class SameAccountInstallMethod:
         """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 or (
-                show_app_row[VERSION_COL] != LOOSE_FILES_MAGIC_VERSION
-            ):
+            if show_app_row[COMMENT_COL] not in ALLOWED_SPECIAL_COMMENTS:
                 # this application object was not created by this tooling
-                raise ApplicationAlreadyExistsError(app.app_name)
+                raise ApplicationCreatedExternallyError(app.app_name)
 
         # expected owner
         ensure_correct_owner(row=show_app_row, role=app.app_role, obj_name=app.app_name)
@@ -132,36 +139,46 @@ 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):
+    def _execute_sql_script(
+        self, script_content: str, database_name: Optional[str] = None
+    ):
         """
-        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.
+        Executing the provided SQL script content.
+        This assumes that a relevant warehouse is already active.
+        If database_name is passed in, it will be used first.
         """
-        with open(sql_script_path) as f:
-            sql_script = f.read()
-            try:
-                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)
+        try:
+            if database_name is not None:
+                self._execute_query(f"use database {database_name}")
+
+            self._execute_queries(script_content)
+        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"):
+                sql_scripts_paths = []
                 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)
+                        sql_scripts_paths.append(hook.sql_script)
                     else:
                         raise ValueError(
                             f"Unsupported application post-deploy hook type: {hook}"
                         )
 
+                env = get_sql_cli_jinja_env(
+                    loader=jinja2.loaders.FileSystemLoader(self.project_root)
+                )
+                scripts_content_list = self._expand_script_templates(
+                    env, cli_context.template_context, sql_scripts_paths
+                )
+
+                for index, sql_script_path in enumerate(sql_scripts_paths):
+                    cc.step(f"Executing SQL script: {sql_script_path}")
+                    self._execute_sql_script(scripts_content_list[index], self.app_name)
+
     def get_all_existing_versions(self) -> SnowflakeCursor:
         """
         Get all existing versions, if defined, for an application package.
@@ -223,7 +240,7 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
                         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:
+                if err.errno != APPLICATION_NO_LONGER_AVAILABLE:
                     generic_sql_error_handler(err)
                 cc.warning(
                     "The application owns other objects but they could not be determined."
@@ -242,10 +259,12 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
                 )
                 raise typer.Exit(1)
         try:
+            cascade_msg = " (cascade)" if cascade else ""
+            cc.step(f"Dropping application object {self.app_name}{cascade_msg}.")
             cascade_sql = " cascade" if cascade else ""
             self._execute_query(f"drop application {self.app_name}{cascade_sql}")
         except ProgrammingError as err:
-            if (err.errno == 93128 or ERROR_MESSAGE_093128 in err.msg) and not cascade:
+            if err.errno == APPLICATION_OWNS_EXTERNAL_OBJECTS 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
@@ -262,89 +281,85 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
         with self.use_role(self.app_role):
 
             # 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
-                )
+            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:
 
-            # 2. Check for an existing application by the same name
-            show_app_row = self.get_existing_app_info()
+                    install_method.ensure_app_usable(self._na_project, show_app_row)
 
-            # 3. If existing application is found, perform a few validations and upgrade the application object.
-            if 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}"
+                        )
 
-                install_method.ensure_app_usable(self._na_project, show_app_row)
+                        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:
+                        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}"
+                        )
 
-                # If all the above checks are in order, proceed to upgrade
                 try:
-                    cc.step(f"Upgrading existing application object {self.app_name}.")
+                    # 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(
-                        f"alter application {self.app_name} upgrade {using_clause}"
+                        dedent(
+                            f"""\
+                        create application {self.app_name}
+                            from application package {self.package_name} {using_clause} {debug_mode_clause}
+                            comment = {SPECIAL_COMMENT}
+                        """
+                        )
                     )
 
-                    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:
-                    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)
-                self._execute_query(
-                    dedent(
-                        f"""\
-                    create application {self.app_name}
-                        from application package {self.package_name} {using_clause} {debug_mode_clause}
-                        comment = {SPECIAL_COMMENT}
-                    """
-                    )
-                )
-
-                # hooks always executed after a create or upgrade
-                self._execute_post_deploy_hooks()
-
-            except ProgrammingError as err:
-                generic_sql_error_handler(err)
+                    generic_sql_error_handler(err)
 
     def process(
         self,

snowflake/cli/plugins/nativeapp/teardown_processor.py

@@ -20,6 +20,7 @@ from typing import Dict, Optional
 
 import typer
 from snowflake.cli.api.console import cli_console as cc
+from snowflake.cli.api.errno import APPLICATION_NO_LONGER_AVAILABLE
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
 from snowflake.cli.plugins.nativeapp.constants import (
     ALLOWED_SPECIAL_COMMENTS,
@@ -28,7 +29,6 @@ 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,
 )
@@ -226,8 +226,13 @@ class NativeAppTeardownProcessor(NativeAppManager, NativeAppCommandProcessor):
             )
             if show_versions_cursor.rowcount is None:
                 raise SnowflakeSQLExecutionError(show_versions_query)
+
             if show_versions_cursor.rowcount > 0:
-                raise CouldNotDropApplicationPackageWithVersions()
+                # allow dropping a package with versions when --force is set
+                if not auto_yes:
+                    raise CouldNotDropApplicationPackageWithVersions(
+                        "Drop versions first, or use --force to override."
+                    )
 
         # 4. Check distribution of the existing application package
         actual_distribution = self.get_app_pkg_distribution_in_snowflake

snowflake/cli/plugins/nativeapp/v2_conversions/v2_to_v1_decorator.py

@@ -0,0 +1,146 @@
+# Copyright (c) 2024 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from functools import wraps
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from click import ClickException
+from snowflake.cli.api.cli_global_context import cli_context, cli_context_manager
+from snowflake.cli.api.project.schemas.entities.application_entity import (
+    ApplicationEntity,
+)
+from snowflake.cli.api.project.schemas.entities.application_package_entity import (
+    ApplicationPackageEntity,
+)
+from snowflake.cli.api.project.schemas.native_app.application import (
+    ApplicationPostDeployHook,
+    SqlScriptHookType,
+)
+from snowflake.cli.api.project.schemas.native_app.path_mapping import PathMapping
+from snowflake.cli.api.project.schemas.project_definition import (
+    DefinitionV11,
+    DefinitionV20,
+)
+
+
+def _convert_v2_artifact_to_v1_dict(
+    v2_artifact: Union[PathMapping, Path]
+) -> Union[Dict, str]:
+    if isinstance(v2_artifact, PathMapping):
+        return {
+            "src": v2_artifact.src,
+            "dest": v2_artifact.dest,
+            "processors": v2_artifact.processors,
+        }
+    return str(v2_artifact)
+
+
+def _convert_v2_post_deploy_hook_to_v1_scripts(
+    v2_post_deploy_hook: ApplicationPostDeployHook,
+) -> List[str]:
+    if isinstance(v2_post_deploy_hook, SqlScriptHookType):
+        return v2_post_deploy_hook.sql_script
+    raise ValueError(f"Unsupported post deploy hook type: {v2_post_deploy_hook}")
+
+
+def _pdf_v2_to_v1(v2_definition: DefinitionV20) -> DefinitionV11:
+    pdfv1: Dict[str, Any] = {"definition_version": "1.1", "native_app": {}}
+
+    app_package_definition: ApplicationPackageEntity = None
+    app_definition: Optional[ApplicationEntity] = None
+
+    for key, entity in v2_definition.entities.items():
+        if entity.get_type() == ApplicationPackageEntity.get_type():
+            if app_package_definition:
+                raise ClickException(
+                    "More than one application package entity exists in the project definition file."
+                )
+            app_package_definition = entity
+        elif entity.get_type() == ApplicationEntity.get_type():
+            if app_definition:
+                raise ClickException(
+                    "More than one application entity exists in the project definition file."
+                )
+            app_definition = entity
+    if not app_package_definition:
+        raise ClickException(
+            "Could not find an application package entity in the project definition file."
+        )
+
+    # NativeApp
+    if app_definition and app_definition.name:
+        pdfv1["native_app"]["name"] = app_definition.name
+    else:
+        pdfv1["native_app"]["name"] = app_package_definition.name.split("_pkg_")[0]
+    pdfv1["native_app"]["artifacts"] = [
+        _convert_v2_artifact_to_v1_dict(a) for a in app_package_definition.artifacts
+    ]
+    pdfv1["native_app"]["source_stage"] = app_package_definition.stage
+    pdfv1["native_app"]["bundle_root"] = str(app_package_definition.bundle_root)
+    pdfv1["native_app"]["generated_root"] = str(app_package_definition.generated_root)
+    pdfv1["native_app"]["deploy_root"] = str(app_package_definition.deploy_root)
+
+    # Package
+    pdfv1["native_app"]["package"] = {}
+    pdfv1["native_app"]["package"]["name"] = app_package_definition.name
+    if app_package_definition.distribution:
+        pdfv1["native_app"]["package"][
+            "distribution"
+        ] = app_package_definition.distribution
+    if app_package_definition.meta and app_package_definition.meta.post_deploy:
+        pdfv1["native_app"]["package"]["scripts"] = [
+            _convert_v2_post_deploy_hook_to_v1_scripts(s)
+            for s in app_package_definition.meta.post_deploy
+        ]
+
+    # Application
+    if app_definition:
+        pdfv1["native_app"]["application"] = {}
+        pdfv1["native_app"]["application"]["name"] = app_definition.name
+        if app_definition.meta and app_definition.meta.role:
+            pdfv1["native_app"]["application"]["role"] = app_definition.meta.role
+        if app_definition.meta and app_definition.meta.post_deploy:
+            pdfv1["native_app"]["application"][
+                "post_deploy"
+            ] = app_definition.meta.post_deploy
+
+    # Override the definition object in global context
+    return DefinitionV11(**pdfv1)
+
+
+def nativeapp_definition_v2_to_v1(func):
+    """
+    A command decorator that attempts to automatically convert a native app project from
+    definition v2 to v1.1. Assumes with_project_definition() has already been called.
+    The definition object in CliGlobalContext will be replaced with the converted object.
+    Exactly one application package entity type is expected, and up to one application
+    entity type is expected.
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        original_pdf: DefinitionV20 = cli_context.project_definition
+        if not original_pdf:
+            raise ValueError(
+                "Project definition could not be found. The nativeapp_definition_v2_to_v1 command decorator assumes with_project_definition() was called before it."
+            )
+        if original_pdf.definition_version == "2":
+            pdfv1 = _pdf_v2_to_v1(original_pdf)
+            cli_context_manager.set_project_definition(pdfv1)
+        return func(*args, **kwargs)
+
+    return wrapper

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

@@ -25,6 +25,7 @@ from snowflake.cli.api.commands.decorators import (
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.output.types import CommandResult, MessageResult, QueryResult
+from snowflake.cli.api.project.project_verification import assert_project_type
 from snowflake.cli.plugins.nativeapp.common_flags import ForceOption, InteractiveOption
 from snowflake.cli.plugins.nativeapp.policy import (
     AllowAlwaysPolicy,
@@ -32,6 +33,9 @@ from snowflake.cli.plugins.nativeapp.policy import (
     DenyAlwaysPolicy,
 )
 from snowflake.cli.plugins.nativeapp.run_processor import NativeAppRunProcessor
+from snowflake.cli.plugins.nativeapp.v2_conversions.v2_to_v1_decorator import (
+    nativeapp_definition_v2_to_v1,
+)
 from snowflake.cli.plugins.nativeapp.version.version_processor import (
     NativeAppVersionCreateProcessor,
     NativeAppVersionDropProcessor,
@@ -46,7 +50,8 @@ log = logging.getLogger(__name__)
 
 
 @app.command(requires_connection=True)
-@with_project_definition("native_app")
+@with_project_definition()
+@nativeapp_definition_v2_to_v1
 def create(
     version: Optional[str] = typer.Argument(
         None,
@@ -71,6 +76,9 @@ def create(
     """
     Adds a new patch to the provided version defined in your application package. If the version does not exist, creates a version with patch 0.
     """
+
+    assert_project_type("native_app")
+
     if version is None and patch is not None:
         raise MissingParameter("Cannot provide a patch without version!")
 
@@ -107,13 +115,17 @@ def create(
 
 
 @app.command("list", requires_connection=True)
-@with_project_definition("native_app")
+@with_project_definition()
+@nativeapp_definition_v2_to_v1
 def version_list(
     **options,
 ) -> CommandResult:
     """
     Lists all versions defined in an application package.
     """
+
+    assert_project_type("native_app")
+
     processor = NativeAppRunProcessor(
         project_definition=cli_context.project_definition.native_app,
         project_root=cli_context.project_root,
@@ -123,7 +135,8 @@ def version_list(
 
 
 @app.command(requires_connection=True)
-@with_project_definition("native_app")
+@with_project_definition()
+@nativeapp_definition_v2_to_v1
 def drop(
     version: Optional[str] = typer.Argument(
         None,
@@ -137,6 +150,9 @@ def drop(
     Drops a version defined in your application package. Versions can either be passed in as an argument to the command or read from the `manifest.yml` file.
     Dropping patches is not allowed.
     """
+
+    assert_project_type("native_app")
+
     is_interactive = False
     if force:
         policy = AllowAlwaysPolicy()

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

@@ -34,6 +34,7 @@ from snowflake.cli.plugins.nativeapp.artifacts import (
 )
 from snowflake.cli.plugins.nativeapp.constants import VERSION_COL
 from snowflake.cli.plugins.nativeapp.exceptions import (
+    ApplicationPackageAlreadyExistsError,
     ApplicationPackageDoesNotExistError,
 )
 from snowflake.cli.plugins.nativeapp.manager import (
@@ -64,12 +65,14 @@ def check_index_changes_in_git_repo(
         # Check if the repo has any changes, including untracked files
         if repo.is_dirty(untracked_files=True):
             cc.warning(
-                "Changes detected in the git repository. (Rerun your command with --skip-git-check flag to ignore this check)"
+                "Changes detected in the git repository. "
+                "(Rerun your command with --skip-git-check flag to ignore this check)"
             )
             repo.git.execute(["git", "status"])
 
             user_prompt = (
-                "You have local changes in this repository that are not part of a previous commit. Do you still want to continue?",
+                "You have local changes in this repository that are not part of a previous commit. "
+                "Do you still want to continue?"
             )
             if not policy.should_proceed(user_prompt):
                 if is_interactive:
@@ -212,7 +215,12 @@ class NativeAppVersionCreateProcessor(NativeAppRunProcessor):
                 is_interactive=is_interactive,
             )
 
-        self.create_app_package()
+        try:
+            self.create_app_package()
+        except ApplicationPackageAlreadyExistsError as e:
+            cc.warning(e.message)
+            if not policy.should_proceed("Proceed with using this package?"):
+                raise typer.Abort() from e
 
         with self.use_role(self.package_role):
             # Now that the application package exists, create shared data

snowflake/cli/plugins/object/commands.py

@@ -33,7 +33,7 @@ app = SnowTyperFactory(
 
 NameArgument = typer.Argument(help="Name of the object")
 ObjectArgument = typer.Argument(
-    help="Type of object. For example table, procedure, streamlit.",
+    help="Type of object. For example table, database, compute-pool.",
     case_sensitive=False,
     show_default=False,
 )

snowflake/cli/plugins/object/manager.py

@@ -36,16 +36,6 @@ def _get_object_names(object_type: str) -> ObjectNames:
     return OBJECT_TO_NAMES[object_type]
 
 
-def _pluralize_object_type(object_type: str) -> str:
-    """
-    Pluralize object type without depending on OBJECT_TO_NAMES.
-    """
-    if object_type.endswith("y"):
-        return object_type[:-1].lower() + "ies"
-    else:
-        return object_type.lower() + "s"
-
-
 class ObjectManager(SqlExecutionMixin):
     def show(
         self,
@@ -85,11 +75,8 @@ class ObjectManager(SqlExecutionMixin):
 
     def create(self, object_type: str, object_data: Dict[str, Any]) -> str:
         rest = RestApi(self._conn)
-        url = rest.determine_url_for_create_query(
-            plural_object_type=_pluralize_object_type(object_type)
-        )
-        if not url:
-            return f"Create operation for type {object_type} is not supported. Try using `sql -q 'CREATE ...'` command"
+        url = rest.determine_url_for_create_query(object_type=object_type)
+
         try:
             response = rest.send_rest_request(url=url, method="post", data=object_data)
             # workaround as SnowflakeRestful class ignores some errors, dropping their info and returns {} instead.