snowflake-cli 3.1.0__py3-none-any.whl → 3.2.1__py3-none-any.whl

snowflake/cli/_plugins/nativeapp/entities/application_package.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import json
-from contextlib import contextmanager
+import re
 from pathlib import Path
 from textwrap import dedent
 from typing import List, Literal, Optional, Union
@@ -11,6 +11,7 @@ from click import BadOptionUsage, ClickException
 from pydantic import Field, field_validator
 from snowflake.cli._plugins.nativeapp.artifacts import (
     BundleMap,
+    VersionInfo,
     build_bundle,
     find_version_info_in_manifest_file,
 )
@@ -40,12 +41,14 @@ from snowflake.cli._plugins.nativeapp.policy import (
     DenyAlwaysPolicy,
     PolicyBase,
 )
+from snowflake.cli._plugins.nativeapp.sf_facade import get_snowflake_facade
+from snowflake.cli._plugins.nativeapp.sf_facade_exceptions import (
+    InsufficientPrivilegesError,
+)
 from snowflake.cli._plugins.nativeapp.utils import needs_confirmation
 from snowflake.cli._plugins.stage.diff import DiffResult
 from snowflake.cli._plugins.stage.manager import StageManager
 from snowflake.cli._plugins.workspace.context import ActionContext
-from snowflake.cli.api.cli_global_context import get_cli_context
-from snowflake.cli.api.console.abc import AbstractConsole
 from snowflake.cli.api.entities.common import EntityBase, get_sql_executor
 from snowflake.cli.api.entities.utils import (
     drop_generic_object,
@@ -56,7 +59,6 @@ from snowflake.cli.api.entities.utils import (
 )
 from snowflake.cli.api.errno import DOES_NOT_EXIST_OR_NOT_AUTHORIZED
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
-from snowflake.cli.api.metrics import CLICounterField
 from snowflake.cli.api.project.schemas.entities.common import (
     EntityModelBase,
     Identifier,
@@ -69,6 +71,7 @@ from snowflake.cli.api.project.schemas.updatable_model import (
 from snowflake.cli.api.project.schemas.v1.native_app.package import DistributionOptions
 from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import PathMapping
 from snowflake.cli.api.project.util import (
+    SCHEMA_AND_NAME,
     append_test_resource_suffix,
     extract_schema,
     identifier_to_show_like_pattern,
@@ -109,8 +112,9 @@ class ApplicationPackageEntityModel(EntityModelBase):
         title="Distribution of the application package created by the Snowflake CLI",
         default="internal",
     )
-    manifest: str = Field(
-        title="Path to manifest.yml",
+    manifest: Optional[str] = Field(
+        title="Path to manifest.yml. Unused and deprecated starting with Snowflake CLI 3.2",
+        default="",
     )
 
     @field_validator("identifier")
@@ -143,25 +147,68 @@ class ApplicationPackageEntityModel(EntityModelBase):
 
         return transformed_artifacts
 
+    @field_validator("stage")
+    @classmethod
+    def validate_source_stage(cls, input_value: str):
+        if not re.match(SCHEMA_AND_NAME, input_value):
+            raise ValueError(
+                "Incorrect value for stage of native_app. Expected format for this field is {schema_name}.{stage_name} "
+            )
+        return input_value
+
 
 class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
     """
     A Native App application package.
     """
 
-    def action_bundle(self, action_ctx: ActionContext, *args, **kwargs):
+    @property
+    def project_root(self) -> Path:
+        return self._workspace_ctx.project_root
+
+    @property
+    def deploy_root(self) -> Path:
+        return self.project_root / self._entity_model.deploy_root
+
+    @property
+    def bundle_root(self) -> Path:
+        return self.project_root / self._entity_model.bundle_root
+
+    @property
+    def generated_root(self) -> Path:
+        return self.deploy_root / self._entity_model.generated_root
+
+    @property
+    def name(self) -> str:
+        return self._entity_model.fqn.name
+
+    @property
+    def role(self) -> str:
         model = self._entity_model
-        workspace_ctx = self._workspace_ctx
-        return self.bundle(
-            project_root=workspace_ctx.project_root,
-            deploy_root=workspace_ctx.project_root / model.deploy_root,
-            bundle_root=workspace_ctx.project_root / model.bundle_root,
-            generated_root=(
-                workspace_ctx.project_root / model.deploy_root / model.generated_root
-            ),
-            package_name=model.identifier,
-            artifacts=model.artifacts,
-        )
+        return (model.meta and model.meta.role) or self._workspace_ctx.default_role
+
+    @property
+    def warehouse(self) -> str:
+        model = self._entity_model
+        return (
+            model.meta and model.meta.warehouse and to_identifier(model.meta.warehouse)
+        ) or to_identifier(self._workspace_ctx.default_warehouse)
+
+    @property
+    def stage_fqn(self) -> str:
+        return f"{self.name}.{self._entity_model.stage}"
+
+    @property
+    def scratch_stage_fqn(self) -> str:
+        return f"{self.name}.{self._entity_model.scratch_stage}"
+
+    @property
+    def post_deploy_hooks(self) -> list[PostDeployHook] | None:
+        model = self._entity_model
+        return model.meta and model.meta.post_deploy
+
+    def action_bundle(self, action_ctx: ActionContext, *args, **kwargs):
+        return self._bundle()
 
     def action_deploy(
         self,
@@ -176,57 +223,94 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         *args,
         **kwargs,
     ):
-        model = self._entity_model
-        workspace_ctx = self._workspace_ctx
-        package_name = model.fqn.identifier
-
-        if force:
-            policy = AllowAlwaysPolicy()
-        elif interactive:
-            policy = AskAlwaysPolicy()
-        else:
-            policy = DenyAlwaysPolicy()
-
-        return self.deploy(
-            console=workspace_ctx.console,
-            project_root=workspace_ctx.project_root,
-            deploy_root=workspace_ctx.project_root / model.deploy_root,
-            bundle_root=workspace_ctx.project_root / model.bundle_root,
-            generated_root=(
-                workspace_ctx.project_root / model.deploy_root / model.generated_root
-            ),
-            artifacts=model.artifacts,
+        return self._deploy(
             bundle_map=None,
-            package_name=package_name,
-            package_role=(model.meta and model.meta.role) or workspace_ctx.default_role,
-            package_distribution=model.distribution,
             prune=prune,
             recursive=recursive,
             paths=paths,
             print_diff=True,
             validate=validate,
-            stage_fqn=stage_fqn or f"{package_name}.{model.stage}",
-            package_warehouse=(
-                (model.meta and model.meta.warehouse) or workspace_ctx.default_warehouse
-            ),
-            post_deploy_hooks=model.meta and model.meta.post_deploy,
-            policy=policy,
+            stage_fqn=stage_fqn or self.stage_fqn,
+            interactive=interactive,
+            force=force,
         )
 
     def action_drop(self, action_ctx: ActionContext, force_drop: bool, *args, **kwargs):
-        model = self._entity_model
-        workspace_ctx = self._workspace_ctx
-        package_name = model.fqn.identifier
-        if model.meta and model.meta.role:
-            package_role = model.meta.role
+        console = self._workspace_ctx.console
+        sql_executor = get_sql_executor()
+        needs_confirm = True
+
+        # 1. If existing application package is not found, exit gracefully
+        show_obj_row = self.get_existing_app_pkg_info()
+        if show_obj_row is None:
+            console.warning(
+                f"Role {self.role} does not own any application package with the name {self.name}, or the application package does not exist."
+            )
+            return
+
+        with sql_executor.use_role(self.role):
+            # 2. Check for versions in the application package
+            show_versions_query = f"show versions in application package {self.name}"
+            show_versions_cursor = sql_executor.execute_query(
+                show_versions_query, cursor_class=DictCursor
+            )
+            if show_versions_cursor.rowcount is None:
+                raise SnowflakeSQLExecutionError(show_versions_query)
+
+            if show_versions_cursor.rowcount > 0:
+                # allow dropping a package with versions when --force is set
+                if not force_drop:
+                    raise CouldNotDropApplicationPackageWithVersions(
+                        "Drop versions first, or use --force to override."
+                    )
+
+        # 3. Check distribution of the existing application package
+        actual_distribution = self.get_app_pkg_distribution_in_snowflake()
+        if not self.verify_project_distribution():
+            console.warning(
+                f"Dropping application package {self.name} with distribution '{actual_distribution}'."
+            )
+
+        # 4. If distribution is internal, check if created by the Snowflake CLI
+        row_comment = show_obj_row[COMMENT_COL]
+        if actual_distribution == INTERNAL_DISTRIBUTION:
+            if row_comment in ALLOWED_SPECIAL_COMMENTS:
+                needs_confirm = False
+            else:
+                if needs_confirmation(needs_confirm, force_drop):
+                    console.warning(
+                        f"Application package {self.name} was not created by Snowflake CLI."
+                    )
         else:
-            package_role = workspace_ctx.default_role
+            if needs_confirmation(needs_confirm, force_drop):
+                console.warning(
+                    f"Application package {self.name} in your Snowflake account has distribution property '{EXTERNAL_DISTRIBUTION}' and could be associated with one or more of your listings on Snowflake Marketplace."
+                )
 
-        self.drop(
-            console=workspace_ctx.console,
-            package_name=package_name,
-            package_role=package_role,
-            force_drop=force_drop,
+        if needs_confirmation(needs_confirm, force_drop):
+            should_drop_object = typer.confirm(
+                dedent(
+                    f"""\
+                        Application package details:
+                        Name: {self.name}
+                        Created on: {show_obj_row["created_on"]}
+                        Distribution: {actual_distribution}
+                        Owner: {show_obj_row[OWNER_COL]}
+                        Comment: {show_obj_row[COMMENT_COL]}
+                        Are you sure you want to drop it?
+                    """
+                )
+            )
+            if not should_drop_object:
+                console.message(f"Did not drop application package {self.name}.")
+                return  # The user desires to keep the application package, therefore exit gracefully
+
+        # All validations have passed, drop object
+        drop_generic_object(
+            console=console,
+            object_type="application package",
+            object_name=(self.name),
+            role=(self.role),
         )
 
     def action_validate(
@@ -238,92 +322,129 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         *args,
         **kwargs,
     ):
-        model = self._entity_model
-        workspace_ctx = self._workspace_ctx
-        package_name = model.fqn.identifier
-        if force:
-            policy = AllowAlwaysPolicy()
-        elif interactive:
-            policy = AskAlwaysPolicy()
-        else:
-            policy = DenyAlwaysPolicy()
-
         self.validate_setup_script(
-            console=workspace_ctx.console,
-            project_root=workspace_ctx.project_root,
-            deploy_root=workspace_ctx.project_root / model.deploy_root,
-            bundle_root=workspace_ctx.project_root / model.bundle_root,
-            generated_root=(
-                workspace_ctx.project_root / model.deploy_root / model.generated_root
-            ),
-            artifacts=model.artifacts,
-            package_name=package_name,
-            package_role=(model.meta and model.meta.role) or workspace_ctx.default_role,
-            package_distribution=model.distribution,
-            prune=True,
-            recursive=True,
-            paths=[],
-            stage_fqn=f"{package_name}.{model.stage}",
-            package_warehouse=(
-                (model.meta and model.meta.warehouse) or workspace_ctx.default_warehouse
-            ),
-            policy=policy,
             use_scratch_stage=use_scratch_stage,
-            scratch_stage_fqn=f"{package_name}.{model.scratch_stage}",
+            interactive=interactive,
+            force=force,
         )
-        workspace_ctx.console.message("Setup script is valid")
+        self._workspace_ctx.console.message("Setup script is valid")
 
     def action_version_list(
         self, action_ctx: ActionContext, *args, **kwargs
     ) -> SnowflakeCursor:
-        model = self._entity_model
-        workspace_ctx = self._workspace_ctx
-        return self.version_list(
-            package_name=model.fqn.identifier,
-            package_role=(model.meta and model.meta.role) or workspace_ctx.default_role,
-        )
+        """
+        Get all existing versions, if defined, for an application package.
+        It executes a 'show versions in application package' query and returns all the results.
+        """
+        sql_executor = get_sql_executor()
+        with sql_executor.use_role(self.role):
+            show_obj_query = f"show versions in application package {self.name}"
+            show_obj_cursor = sql_executor.execute_query(show_obj_query)
+
+            if show_obj_cursor.rowcount is None:
+                raise SnowflakeSQLExecutionError(show_obj_query)
+
+            return show_obj_cursor
 
     def action_version_create(
         self,
         action_ctx: ActionContext,
         version: Optional[str],
         patch: Optional[int],
+        label: Optional[str],
         skip_git_check: bool,
         interactive: bool,
         force: bool,
         *args,
         **kwargs,
     ):
-        model = self._entity_model
-        workspace_ctx = self._workspace_ctx
-        package_name = model.fqn.identifier
-        return self.version_create(
-            console=workspace_ctx.console,
-            project_root=workspace_ctx.project_root,
-            deploy_root=workspace_ctx.project_root / model.deploy_root,
-            bundle_root=workspace_ctx.project_root / model.bundle_root,
-            generated_root=(
-                workspace_ctx.project_root / model.deploy_root / model.generated_root
-            ),
-            artifacts=model.artifacts,
-            package_name=package_name,
-            package_role=(model.meta and model.meta.role) or workspace_ctx.default_role,
-            package_distribution=model.distribution,
+        """
+        Create a version and/or patch for a new or existing application package.
+        Always performs a deploy action before creating version or patch.
+        If version is not provided in CLI, bundle is performed to read version from manifest.yml. Raises a ClickException if version is not found.
+        """
+        console = self._workspace_ctx.console
+
+        if force:
+            policy = AllowAlwaysPolicy()
+        elif interactive:
+            policy = AskAlwaysPolicy()
+        else:
+            policy = DenyAlwaysPolicy()
+
+        if skip_git_check:
+            git_policy = DenyAlwaysPolicy()
+        else:
+            git_policy = AllowAlwaysPolicy()
+
+        bundle_map = self._bundle()
+        resolved_version, resolved_patch, resolved_label = self.resolve_version_info(
+            version=version,
+            patch=patch,
+            label=label,
+            bundle_map=bundle_map,
+            policy=policy,
+            interactive=interactive,
+        )
+
+        if git_policy.should_proceed():
+            self.check_index_changes_in_git_repo(policy=policy, interactive=interactive)
+
+        self._deploy(
+            bundle_map=bundle_map,
             prune=True,
             recursive=True,
-            paths=None,
+            paths=[],
             print_diff=True,
             validate=True,
-            stage_fqn=f"{package_name}.{model.stage}",
-            package_warehouse=(
-                (model.meta and model.meta.warehouse) or workspace_ctx.default_warehouse
-            ),
-            post_deploy_hooks=model.meta and model.meta.post_deploy,
-            version=version,
-            patch=patch,
-            skip_git_check=skip_git_check,
-            force=force,
+            stage_fqn=self.stage_fqn,
             interactive=interactive,
+            force=force,
+        )
+
+        # Warn if the version exists in a release directive(s)
+        try:
+            existing_release_directives = (
+                self.get_existing_release_directive_info_for_version(resolved_version)
+            )
+        except InsufficientPrivilegesError:
+            warning = (
+                "Could not check for existing release directives due to insufficient privileges. "
+                "The MANAGE RELEASES privilege is required to check for existing release directives."
+            )
+        else:
+            if existing_release_directives:
+                release_directive_names = ", ".join(
+                    row["name"] for row in existing_release_directives
+                )
+                warning = f"Version {resolved_version} already defined in application package {self.name} and in release directive(s): {release_directive_names}."
+            else:
+                warning = ""
+
+        if warning:
+            console.warning(warning)
+            user_prompt = (
+                f"Are you sure you want to create a new patch for version {resolved_version} in application "
+                f"package {self.name}? Once added, this operation cannot be undone."
+            )
+            if not policy.should_proceed(user_prompt):
+                if interactive:
+                    console.message("Not creating a new patch.")
+                    raise typer.Exit(0)
+                else:
+                    console.message(
+                        "Cannot create a new patch non-interactively without --force."
+                    )
+                    raise typer.Exit(1)
+
+        # Define a new version in the application package
+        if not self.get_existing_version_info(resolved_version):
+            self.add_new_version(version=resolved_version, label=resolved_label)
+            return  # A new version created automatically has patch 0, we do not need to further increment the patch.
+
+        # Add a new patch to an existing (old) version
+        self.add_new_patch_to_version(
+            version=resolved_version, patch=resolved_patch, label=resolved_label
         )
 
     def action_version_drop(
@@ -335,104 +456,148 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         *args,
         **kwargs,
     ):
-        model = self._entity_model
-        workspace_ctx = self._workspace_ctx
-        package_name = model.fqn.identifier
-        return self.version_drop(
-            console=workspace_ctx.console,
-            project_root=workspace_ctx.project_root,
-            deploy_root=workspace_ctx.project_root / model.deploy_root,
-            bundle_root=workspace_ctx.project_root / model.bundle_root,
-            generated_root=(
-                workspace_ctx.project_root / model.deploy_root / model.generated_root
-            ),
-            artifacts=model.artifacts,
-            package_name=package_name,
-            package_role=(model.meta and model.meta.role) or workspace_ctx.default_role,
-            package_distribution=model.distribution,
-            version=version,
-            force=force,
-            interactive=interactive,
+        """
+        Drops a version defined in an application package. If --force is provided, then no user prompts will be executed.
+        """
+        console = self._workspace_ctx.console
+
+        if force:
+            interactive = False
+            policy = AllowAlwaysPolicy()
+        else:
+            policy = AskAlwaysPolicy() if interactive else DenyAlwaysPolicy()
+
+        # 1. Check for existing an existing application package
+        show_obj_row = self.get_existing_app_pkg_info()
+        if not show_obj_row:
+            raise ApplicationPackageDoesNotExistError(self.name)
+
+        # 2. Check distribution of the existing application package
+        actual_distribution = self.get_app_pkg_distribution_in_snowflake()
+        if not self.verify_project_distribution(
+            expected_distribution=actual_distribution
+        ):
+            console.warning(
+                f"Continuing to execute version drop on application package "
+                f"{self.name} with distribution '{actual_distribution}'."
+            )
+
+        # 3. If the user did not pass in a version string, determine from manifest.yml
+        if not version:
+            console.message(
+                dedent(
+                    f"""\
+                        Version was not provided through the Snowflake CLI. Checking version in the manifest.yml instead.
+                        This step will bundle your app artifacts to determine the location of the manifest.yml file.
+                    """
+                )
+            )
+            self._bundle()
+            version_info = find_version_info_in_manifest_file(self.deploy_root)
+            version = version_info.version_name
+            if not version:
+                raise ClickException(
+                    "Manifest.yml file does not contain a value for the version field."
+                )
+
+        # Make the version a valid identifier, adding quotes if necessary
+        version = to_identifier(version)
+
+        console.step(
+            f"About to drop version {version} in application package {self.name}."
         )
 
-    @staticmethod
-    def bundle(
-        project_root: Path,
-        deploy_root: Path,
-        bundle_root: Path,
-        generated_root: Path,
-        artifacts: list[PathMapping],
-        package_name: str,
-    ):
-        bundle_map = build_bundle(project_root, deploy_root, artifacts)
+        # If user did not provide --force, ask for confirmation
+        user_prompt = (
+            f"Are you sure you want to drop version {version} "
+            f"in application package {self.name}? "
+            f"Once dropped, this operation cannot be undone."
+        )
+        if not policy.should_proceed(user_prompt):
+            if interactive:
+                console.message("Not dropping version.")
+                raise typer.Exit(0)
+            else:
+                console.message(
+                    "Cannot drop version non-interactively without --force."
+                )
+                raise typer.Exit(1)
+
+        # Drop the version
+        sql_executor = get_sql_executor()
+        with sql_executor.use_role(self.role):
+            try:
+                sql_executor.execute_query(
+                    f"alter application package {self.name} drop version {version}"
+                )
+            except ProgrammingError as err:
+                raise err  # e.g. version is referenced in a release directive(s)
+
+        console.message(
+            f"Version {version} in application package {self.name} dropped successfully."
+        )
+
+    def _bundle(self):
+        model = self._entity_model
+        bundle_map = build_bundle(self.project_root, self.deploy_root, model.artifacts)
         bundle_context = BundleContext(
-            package_name=package_name,
-            artifacts=artifacts,
-            project_root=project_root,
-            bundle_root=bundle_root,
-            deploy_root=deploy_root,
-            generated_root=generated_root,
+            package_name=self.name,
+            artifacts=model.artifacts,
+            project_root=self.project_root,
+            bundle_root=self.bundle_root,
+            deploy_root=self.deploy_root,
+            generated_root=self.generated_root,
         )
         compiler = NativeAppCompiler(bundle_context)
         compiler.compile_artifacts()
         return bundle_map
 
-    @classmethod
-    def deploy(
-        cls,
-        console: AbstractConsole,
-        project_root: Path,
-        deploy_root: Path,
-        bundle_root: Path,
-        generated_root: Path,
-        artifacts: list[PathMapping],
+    def _deploy(
+        self,
         bundle_map: BundleMap | None,
-        package_name: str,
-        package_role: str,
-        package_distribution: str,
-        package_warehouse: str | None,
         prune: bool,
         recursive: bool,
-        paths: List[Path] | None,
+        paths: list[Path],
         print_diff: bool,
         validate: bool,
         stage_fqn: str,
-        post_deploy_hooks: list[PostDeployHook] | None,
-        policy: PolicyBase,
+        interactive: bool,
+        force: bool,
+        run_post_deploy_hooks: bool = True,
     ) -> DiffResult:
+        model = self._entity_model
+        workspace_ctx = self._workspace_ctx
+        if force:
+            policy = AllowAlwaysPolicy()
+        elif interactive:
+            policy = AskAlwaysPolicy()
+        else:
+            policy = DenyAlwaysPolicy()
+
+        console = workspace_ctx.console
+        stage_fqn = stage_fqn or self.stage_fqn
+
         # 1. Create a bundle if one wasn't passed in
-        bundle_map = bundle_map or cls.bundle(
-            project_root=project_root,
-            deploy_root=deploy_root,
-            bundle_root=bundle_root,
-            generated_root=generated_root,
-            artifacts=artifacts,
-            package_name=package_name,
-        )
+        bundle_map = bundle_map or self._bundle()
 
         # 2. Create an empty application package, if none exists
         try:
-            cls.create_app_package(
-                console=console,
-                package_name=package_name,
-                package_role=package_role,
-                package_distribution=package_distribution,
-            )
+            self.create_app_package()
         except ApplicationPackageAlreadyExistsError as e:
             console.warning(e.message)
             if not policy.should_proceed("Proceed with using this package?"):
                 raise typer.Abort() from e
 
-        with get_sql_executor().use_role(package_role):
+        with get_sql_executor().use_role(self.role):
             # 3. Upload files from deploy root local folder to the above stage
             stage_schema = extract_schema(stage_fqn)
             diff = sync_deploy_root_with_stage(
                 console=console,
-                deploy_root=deploy_root,
-                package_name=package_name,
+                deploy_root=self.deploy_root,
+                package_name=self.name,
                 stage_schema=stage_schema,
                 bundle_map=bundle_map,
-                role=package_role,
+                role=self.role,
                 prune=prune,
                 recursive=recursive,
                 stage_fqn=stage_fqn,
@@ -440,228 +605,19 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
                 print_diff=print_diff,
             )
 
-            cls.execute_post_deploy_hooks(
-                console=console,
-                project_root=project_root,
-                post_deploy_hooks=post_deploy_hooks,
-                package_name=package_name,
-                package_warehouse=package_warehouse,
-            )
+        if run_post_deploy_hooks:
+            self.execute_post_deploy_hooks()
 
         if validate:
-            cls.validate_setup_script(
-                console=console,
-                project_root=project_root,
-                deploy_root=deploy_root,
-                bundle_root=bundle_root,
-                generated_root=generated_root,
-                artifacts=artifacts,
-                package_name=package_name,
-                package_role=package_role,
-                package_distribution=package_distribution,
-                prune=prune,
-                recursive=recursive,
-                paths=paths,
-                stage_fqn=stage_fqn,
-                package_warehouse=package_warehouse,
-                policy=policy,
+            self.validate_setup_script(
                 use_scratch_stage=False,
-                scratch_stage_fqn="",
+                interactive=interactive,
+                force=force,
             )
 
         return diff
 
-    @staticmethod
-    def version_list(package_name: str, package_role: str) -> SnowflakeCursor:
-        """
-        Get all existing versions, if defined, for an application package.
-        It executes a 'show versions in application package' query and returns all the results.
-        """
-        sql_executor = get_sql_executor()
-        with sql_executor.use_role(package_role):
-            show_obj_query = f"show versions in application package {package_name}"
-            show_obj_cursor = sql_executor.execute_query(show_obj_query)
-
-            if show_obj_cursor.rowcount is None:
-                raise SnowflakeSQLExecutionError(show_obj_query)
-
-            return show_obj_cursor
-
-    @classmethod
-    def version_create(
-        cls,
-        console: AbstractConsole,
-        project_root: Path,
-        deploy_root: Path,
-        bundle_root: Path,
-        generated_root: Path,
-        artifacts: list[PathMapping],
-        package_name: str,
-        package_role: str,
-        package_distribution: str,
-        package_warehouse: str | None,
-        prune: bool,
-        recursive: bool,
-        paths: List[Path] | None,
-        print_diff: bool,
-        validate: bool,
-        stage_fqn: str,
-        post_deploy_hooks: list[PostDeployHook] | None,
-        version: Optional[str],
-        patch: Optional[int],
-        force: bool,
-        interactive: bool,
-        skip_git_check: bool,
-    ):
-        """
-        Perform bundle, application package creation, stage upload, version and/or patch to an application package.
-        """
-        is_interactive = False
-        if force:
-            policy = AllowAlwaysPolicy()
-        elif interactive:
-            is_interactive = True
-            policy = AskAlwaysPolicy()
-        else:
-            policy = DenyAlwaysPolicy()
-
-        if skip_git_check:
-            git_policy = DenyAlwaysPolicy()
-        else:
-            git_policy = AllowAlwaysPolicy()
-
-        # Make sure version is not None before proceeding any further.
-        # This will raise an exception if version information is not found. Patch can be None.
-        bundle_map = None
-        if not version:
-            console.message(
-                dedent(
-                    f"""\
-                        Version was not provided through the Snowflake CLI. Checking version in the manifest.yml instead.
-                        This step will bundle your app artifacts to determine the location of the manifest.yml file.
-                    """
-                )
-            )
-            bundle_map = cls.bundle(
-                project_root=project_root,
-                deploy_root=deploy_root,
-                bundle_root=bundle_root,
-                generated_root=generated_root,
-                artifacts=artifacts,
-                package_name=package_name,
-            )
-            version, patch = find_version_info_in_manifest_file(deploy_root)
-            if not version:
-                raise ClickException(
-                    "Manifest.yml file does not contain a value for the version field."
-                )
-
-        # Check if --patch needs to throw a bad option error, either if application package does not exist or if version does not exist
-        if patch is not None:
-            try:
-                if not cls.get_existing_version_info(
-                    version, package_name, package_role
-                ):
-                    raise BadOptionUsage(
-                        option_name="patch",
-                        message=f"Cannot create a custom patch when version {version} is not defined in the application package {package_name}. Try again without using --patch.",
-                    )
-            except ApplicationPackageDoesNotExistError as app_err:
-                raise BadOptionUsage(
-                    option_name="patch",
-                    message=f"Cannot create a custom patch when application package {package_name} does not exist. Try again without using --patch.",
-                )
-
-        if git_policy.should_proceed():
-            cls.check_index_changes_in_git_repo(
-                console=console,
-                project_root=project_root,
-                policy=policy,
-                is_interactive=is_interactive,
-            )
-
-        cls.deploy(
-            console=console,
-            project_root=project_root,
-            deploy_root=deploy_root,
-            bundle_root=bundle_root,
-            generated_root=generated_root,
-            artifacts=artifacts,
-            bundle_map=bundle_map,
-            package_name=package_name,
-            package_role=package_role,
-            package_distribution=package_distribution,
-            prune=prune,
-            recursive=recursive,
-            paths=paths,
-            print_diff=print_diff,
-            validate=validate,
-            stage_fqn=stage_fqn,
-            package_warehouse=package_warehouse,
-            post_deploy_hooks=post_deploy_hooks,
-            policy=policy,
-        )
-
-        # Warn if the version exists in a release directive(s)
-        existing_release_directives = (
-            cls.get_existing_release_directive_info_for_version(
-                package_name, package_role, version
-            )
-        )
-
-        if existing_release_directives:
-            release_directive_names = ", ".join(
-                row["name"] for row in existing_release_directives
-            )
-            console.warning(
-                dedent(
-                    f"""\
-                    Version {version} already defined in application package {package_name} and in release directive(s): {release_directive_names}.
-                    """
-                )
-            )
-
-            user_prompt = (
-                f"Are you sure you want to create a new patch for version {version} in application "
-                f"package {package_name}? Once added, this operation cannot be undone."
-            )
-            if not policy.should_proceed(user_prompt):
-                if is_interactive:
-                    console.message("Not creating a new patch.")
-                    raise typer.Exit(0)
-                else:
-                    console.message(
-                        "Cannot create a new patch non-interactively without --force."
-                    )
-                    raise typer.Exit(1)
-
-        # Define a new version in the application package
-        if not cls.get_existing_version_info(version, package_name, package_role):
-            cls.add_new_version(
-                console=console,
-                package_name=package_name,
-                package_role=package_role,
-                stage_fqn=stage_fqn,
-                version=version,
-            )
-            return  # A new version created automatically has patch 0, we do not need to further increment the patch.
-
-        # Add a new patch to an existing (old) version
-        cls.add_new_patch_to_version(
-            console=console,
-            package_name=package_name,
-            package_role=package_role,
-            stage_fqn=stage_fqn,
-            version=version,
-            patch=patch,
-        )
-
-    @staticmethod
-    def get_existing_version_info(
-        version: str,
-        package_name: str,
-        package_role: str,
-    ) -> Optional[dict]:
+    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
@@ -669,9 +625,9 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         returns None.
         """
         sql_executor = get_sql_executor()
-        with sql_executor.use_role(package_role):
+        with sql_executor.use_role(self.role):
             try:
-                query = f"show versions like {identifier_to_show_like_pattern(version)} in application package {package_name}"
+                query = f"show versions like {identifier_to_show_like_pattern(version)} in application package {self.name}"
                 cursor = sql_executor.execute_query(query, cursor_class=DictCursor)
 
                 if cursor.rowcount is None:
@@ -688,116 +644,75 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
 
             except ProgrammingError as err:
                 if err.msg.__contains__("does not exist or not authorized"):
-                    raise ApplicationPackageDoesNotExistError(package_name)
+                    raise ApplicationPackageDoesNotExistError(self.name)
                 else:
                     generic_sql_error_handler(err=err)
                     return None
 
-    @classmethod
     def get_existing_release_directive_info_for_version(
-        cls,
-        package_name: str,
-        package_role: str,
-        version: str,
+        self, version: str
     ) -> List[dict]:
         """
         Get all existing release directives, if present, set on the version defined in an application package.
         It executes a 'show release directives in application package' query and returns the filtered results, if they exist.
         """
-        sql_executor = get_sql_executor()
-        with sql_executor.use_role(package_role):
-            show_obj_query = (
-                f"show release directives in application package {package_name}"
-            )
-            show_obj_cursor = sql_executor.execute_query(
-                show_obj_query, cursor_class=DictCursor
-            )
-
-            if show_obj_cursor.rowcount is None:
-                raise SnowflakeSQLExecutionError(show_obj_query)
-
-            show_obj_rows = find_all_rows(
-                show_obj_cursor,
-                lambda row: row[VERSION_COL] == unquote_identifier(version),
-            )
-
-            return show_obj_rows
+        release_directives = get_snowflake_facade().show_release_directives(
+            self.name, self.role
+        )
+        return [
+            directive
+            for directive in release_directives
+            if directive[VERSION_COL] == unquote_identifier(version)
+        ]
 
-    @classmethod
-    def add_new_version(
-        cls,
-        console: AbstractConsole,
-        package_name: str,
-        package_role: str,
-        stage_fqn: str,
-        version: str,
-    ) -> None:
+    def add_new_version(self, version: str, label: str | None = None) -> None:
         """
-        Defines a new version in an existing application package.
+        Add a new version with an optional label in application package.
         """
-        # Make the version a valid identifier, adding quotes if necessary
-        version = to_identifier(version)
-        sql_executor = get_sql_executor()
-        with sql_executor.use_role(package_role):
-            console.step(
-                f"Defining a new version {version} in application package {package_name}"
-            )
-            add_version_query = dedent(
-                f"""\
-                    alter application package {package_name}
-                        add version {version}
-                        using @{stage_fqn}
-                """
-            )
-            sql_executor.execute_query(add_version_query, cursor_class=DictCursor)
-            console.message(
-                f"Version {version} created for application package {package_name}."
-            )
+        console = self._workspace_ctx.console
+        with_label_prompt = f" labeled {label}" if label else ""
+
+        console.step(
+            f"Defining a new version {version}{with_label_prompt} in application package {self.name}"
+        )
+        get_snowflake_facade().create_version_in_package(
+            role=self.role,
+            package_name=self.name,
+            stage_fqn=self.stage_fqn,
+            version=version,
+            label=label,
+        )
+        console.message(
+            f"Version {version}{with_label_prompt} created for application package {self.name}."
+        )
 
-    @classmethod
     def add_new_patch_to_version(
-        cls,
-        console: AbstractConsole,
-        package_name: str,
-        package_role: str,
-        stage_fqn: str,
-        version: str,
-        patch: Optional[int] = None,
+        self, version: str, patch: int | None = None, label: str | None = None
     ):
         """
         Add a new patch, optionally a custom one, to an existing version in an application package.
         """
-        # Make the version a valid identifier, adding quotes if necessary
-        version = to_identifier(version)
-        sql_executor = get_sql_executor()
-        with sql_executor.use_role(package_role):
-            console.step(
-                f"Adding new patch to version {version} defined in application package {package_name}"
-            )
-            add_version_query = dedent(
-                f"""\
-                    alter application package {package_name}
-                        add patch {patch if patch else ""} for version {version}
-                        using @{stage_fqn}
-                """
-            )
-            result_cursor = sql_executor.execute_query(
-                add_version_query, cursor_class=DictCursor
-            )
+        console = self._workspace_ctx.console
 
-            show_row = result_cursor.fetchall()[0]
-            new_patch = show_row["patch"]
-            console.message(
-                f"Patch {new_patch} created for version {version} defined in application package {package_name}."
-            )
+        with_label_prompt = f" labeled {label}" if label else ""
+
+        console.step(
+            f"Adding new patch to version {version}{with_label_prompt} defined in application package {self.name}"
+        )
+        new_patch = get_snowflake_facade().add_patch_to_package_version(
+            role=self.role,
+            package_name=self.name,
+            stage_fqn=self.stage_fqn,
+            version=version,
+            patch=patch,
+            label=label,
+        )
+        console.message(
+            f"Patch {new_patch}{with_label_prompt} created for version {version} defined in application package {self.name}."
+        )
 
-    @classmethod
     def check_index_changes_in_git_repo(
-        cls,
-        console: AbstractConsole,
-        project_root: Path,
-        policy: PolicyBase,
-        is_interactive: bool,
+        self, policy: PolicyBase, interactive: bool
     ) -> None:
         """
         Checks if the project root, i.e. the native apps project is a git repository. If it is a git repository,
@@ -807,8 +722,10 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         from git import Repo
         from git.exc import InvalidGitRepositoryError
 
+        console = self._workspace_ctx.console
+
         try:
-            repo = Repo(project_root, search_parent_directories=True)
+            repo = Repo(self.project_root, search_parent_directories=True)
             assert repo.git_dir is not None
 
             # Check if the repo has any changes, including untracked files
@@ -824,7 +741,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
                     "Do you still want to continue?"
                 )
                 if not policy.should_proceed(user_prompt):
-                    if is_interactive:
+                    if interactive:
                         console.message("Not creating a new version.")
                         raise typer.Exit(0)
                     else:
@@ -836,141 +753,26 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         except InvalidGitRepositoryError:
             pass  # not a git repository, which is acceptable
 
-    @classmethod
-    def version_drop(
-        cls,
-        console: AbstractConsole,
-        project_root: Path,
-        deploy_root: Path,
-        bundle_root: Path,
-        generated_root: Path,
-        artifacts: list[PathMapping],
-        package_name: str,
-        package_role: str,
-        package_distribution: str,
-        version: Optional[str],
-        force: bool,
-        interactive: bool,
-    ):
-        """
-        Drops a version defined in an application package. If --force is provided, then no user prompts will be executed.
-        """
-        if force:
-            interactive = False
-            policy = AllowAlwaysPolicy()
-        else:
-            policy = AskAlwaysPolicy() if interactive else DenyAlwaysPolicy()
-
-        # 1. Check for existing an existing application package
-        show_obj_row = cls.get_existing_app_pkg_info(package_name, package_role)
-        if not show_obj_row:
-            raise ApplicationPackageDoesNotExistError(package_name)
-
-        # 2. Check distribution of the existing application package
-        actual_distribution = cls.get_app_pkg_distribution_in_snowflake(
-            package_name, package_role
-        )
-        if not cls.verify_project_distribution(
-            console=console,
-            package_name=package_name,
-            package_role=package_role,
-            package_distribution=package_distribution,
-            expected_distribution=actual_distribution,
-        ):
-            console.warning(
-                f"Continuing to execute version drop on application package "
-                f"{package_name} with distribution '{actual_distribution}'."
-            )
-
-        # 3. If the user did not pass in a version string, determine from manifest.yml
-        if not version:
-            console.message(
-                dedent(
-                    f"""\
-                        Version was not provided through the Snowflake CLI. Checking version in the manifest.yml instead.
-                        This step will bundle your app artifacts to determine the location of the manifest.yml file.
-                    """
-                )
-            )
-            cls.bundle(
-                project_root=project_root,
-                deploy_root=deploy_root,
-                bundle_root=bundle_root,
-                generated_root=generated_root,
-                artifacts=artifacts,
-                package_name=package_name,
-            )
-            version, _ = find_version_info_in_manifest_file(deploy_root)
-            if not version:
-                raise ClickException(
-                    "Manifest.yml file does not contain a value for the version field."
-                )
-
-        # Make the version a valid identifier, adding quotes if necessary
-        version = to_identifier(version)
-
-        console.step(
-            f"About to drop version {version} in application package {package_name}."
-        )
-
-        # If user did not provide --force, ask for confirmation
-        user_prompt = (
-            f"Are you sure you want to drop version {version} "
-            f"in application package {package_name}? "
-            f"Once dropped, this operation cannot be undone."
-        )
-        if not policy.should_proceed(user_prompt):
-            if interactive:
-                console.message("Not dropping version.")
-                raise typer.Exit(0)
-            else:
-                console.message(
-                    "Cannot drop version non-interactively without --force."
-                )
-                raise typer.Exit(1)
-
-        # Drop the version
-        sql_executor = get_sql_executor()
-        with sql_executor.use_role(package_role):
-            try:
-                sql_executor.execute_query(
-                    f"alter application package {package_name} drop version {version}"
-                )
-            except ProgrammingError as err:
-                raise err  # e.g. version is referenced in a release directive(s)
-
-        console.message(
-            f"Version {version} in application package {package_name} dropped successfully."
-        )
-
-    @staticmethod
-    def get_existing_app_pkg_info(
-        package_name: str,
-        package_role: str,
-    ) -> Optional[dict]:
+    def get_existing_app_pkg_info(self) -> Optional[dict]:
         """
         Check for an existing application package by the same name as in project definition, in account.
         It executes a 'show application packages like' query and returns the result as single row, if one exists.
         """
         sql_executor = get_sql_executor()
-        with sql_executor.use_role(package_role):
+        with sql_executor.use_role(self.role):
             return sql_executor.show_specific_object(
-                "application packages", package_name, name_col=NAME_COL
+                "application packages", self.name, name_col=NAME_COL
             )
 
-    @staticmethod
-    def get_app_pkg_distribution_in_snowflake(
-        package_name: str,
-        package_role: str,
-    ) -> str:
+    def get_app_pkg_distribution_in_snowflake(self) -> str:
         """
         Returns the 'distribution' attribute of a 'describe application package' SQL query, in lowercase.
         """
         sql_executor = get_sql_executor()
-        with sql_executor.use_role(package_role):
+        with sql_executor.use_role(self.role):
             try:
                 desc_cursor = sql_executor.execute_query(
-                    f"describe application package {package_name}"
+                    f"describe application package {self.name}"
                 )
             except ProgrammingError as err:
                 generic_sql_error_handler(err)
@@ -984,36 +786,31 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         raise ObjectPropertyNotFoundError(
             property_name="distribution",
             object_type="application package",
-            object_name=package_name,
+            object_name=self.name,
         )
 
-    @classmethod
     def verify_project_distribution(
-        cls,
-        console: AbstractConsole,
-        package_name: str,
-        package_role: str,
-        package_distribution: str,
+        self,
         expected_distribution: Optional[str] = None,
     ) -> bool:
         """
         Returns true if the 'distribution' attribute of an existing application package in snowflake
         is the same as the the attribute specified in project definition file.
         """
+        model = self._entity_model
+        workspace_ctx = self._workspace_ctx
+
         actual_distribution = (
             expected_distribution
             if expected_distribution
-            else cls.get_app_pkg_distribution_in_snowflake(
-                package_name=package_name,
-                package_role=package_role,
-            )
+            else self.get_app_pkg_distribution_in_snowflake()
         )
-        project_def_distribution = package_distribution.lower()
+        project_def_distribution = model.distribution.lower()
         if actual_distribution != project_def_distribution:
-            console.warning(
+            workspace_ctx.console.warning(
                 dedent(
                     f"""\
-                    Application package {package_name} in your Snowflake account has distribution property {actual_distribution},
+                    Application package {self.name} in your Snowflake account has distribution property {actual_distribution},
                     which does not match the value specified in project definition file: {project_def_distribution}.
                     """
                 )
@@ -1021,57 +818,24 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
             return False
         return True
 
-    @staticmethod
-    @contextmanager
-    def use_package_warehouse(
-        package_warehouse: Optional[str],
-    ):
-        if package_warehouse:
-            with get_sql_executor().use_warehouse(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.
-                """
-                )
-            )
-
-    @classmethod
-    def create_app_package(
-        cls,
-        console: AbstractConsole,
-        package_name: str,
-        package_role: str,
-        package_distribution: str,
-    ) -> None:
+    def create_app_package(self) -> None:
         """
         Creates the application package with our up-to-date stage if none exists.
         """
+        model = self._entity_model
+        console = self._workspace_ctx.console
 
-        # 1. Check for existing existing application package
-        show_obj_row = cls.get_existing_app_pkg_info(
-            package_name=package_name,
-            package_role=package_role,
-        )
+        # 1. Check for existing application package
+        show_obj_row = self.get_existing_app_pkg_info()
 
         if show_obj_row:
             # 2. Check distribution of the existing application package
-            actual_distribution = cls.get_app_pkg_distribution_in_snowflake(
-                package_name=package_name,
-                package_role=package_role,
-            )
-            if not cls.verify_project_distribution(
-                console=console,
-                package_name=package_name,
-                package_role=package_role,
-                package_distribution=package_distribution,
-                expected_distribution=actual_distribution,
+            actual_distribution = self.get_app_pkg_distribution_in_snowflake()
+            if not self.verify_project_distribution(
+                expected_distribution=actual_distribution
             ):
                 console.warning(
-                    f"Continuing to execute `snow app run` on application package {package_name} with distribution '{actual_distribution}'."
+                    f"Continuing to execute `snow app run` on application package {self.name} with distribution '{actual_distribution}'."
                 )
 
             # 3. If actual_distribution is external, skip comment check
@@ -1079,88 +843,47 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
                 row_comment = show_obj_row[COMMENT_COL]
 
                 if row_comment not in ALLOWED_SPECIAL_COMMENTS:
-                    raise ApplicationPackageAlreadyExistsError(package_name)
+                    raise ApplicationPackageAlreadyExistsError(self.name)
 
             return
 
         # If no application package pre-exists, create an application package, with the specified distribution in the project definition file.
         sql_executor = get_sql_executor()
-        with sql_executor.use_role(package_role):
-            console.step(f"Creating new application package {package_name} in account.")
+        with sql_executor.use_role(self.role):
+            console.step(f"Creating new application package {self.name} in account.")
             sql_executor.execute_query(
                 dedent(
                     f"""\
-                    create application package {package_name}
+                    create application package {self.name}
                         comment = {SPECIAL_COMMENT}
-                        distribution = {package_distribution}
+                        distribution = {model.distribution}
                 """
                 )
             )
 
-    @classmethod
-    def execute_post_deploy_hooks(
-        cls,
-        console: AbstractConsole,
-        project_root: Path,
-        post_deploy_hooks: Optional[List[PostDeployHook]],
-        package_name: str,
-        package_warehouse: Optional[str],
-    ):
-        get_cli_context().metrics.set_counter_default(
-            CLICounterField.POST_DEPLOY_SCRIPTS, 0
+    def execute_post_deploy_hooks(self):
+        execute_post_deploy_hooks(
+            console=self._workspace_ctx.console,
+            project_root=self.project_root,
+            post_deploy_hooks=self.post_deploy_hooks,
+            deployed_object_type="application package",
+            role_name=self.role,
+            warehouse_name=self.warehouse,
+            database_name=self.name,
         )
 
-        if post_deploy_hooks:
-            with cls.use_package_warehouse(package_warehouse):
-                execute_post_deploy_hooks(
-                    console=console,
-                    project_root=project_root,
-                    post_deploy_hooks=post_deploy_hooks,
-                    deployed_object_type="application package",
-                    database_name=package_name,
-                )
-
-    @classmethod
     def validate_setup_script(
-        cls,
-        console: AbstractConsole,
-        project_root: Path,
-        deploy_root: Path,
-        bundle_root: Path,
-        generated_root: Path,
-        artifacts: list[PathMapping],
-        package_name: str,
-        package_role: str,
-        package_distribution: str,
-        package_warehouse: str | None,
-        prune: bool,
-        recursive: bool,
-        paths: List[Path] | None,
-        stage_fqn: str,
-        policy: PolicyBase,
-        use_scratch_stage: bool,
-        scratch_stage_fqn: str,
+        self, use_scratch_stage: bool, interactive: bool, force: bool
     ):
+        workspace_ctx = self._workspace_ctx
+        console = workspace_ctx.console
+
         """Validates Native App setup script SQL."""
         with console.phase(f"Validating Snowflake Native App setup script."):
-            validation_result = cls.get_validation_result_static(
-                console=console,
-                project_root=project_root,
-                deploy_root=deploy_root,
-                bundle_root=bundle_root,
-                generated_root=generated_root,
-                artifacts=artifacts,
-                package_name=package_name,
-                package_role=package_role,
-                package_distribution=package_distribution,
-                prune=prune,
-                recursive=recursive,
-                paths=paths,
-                stage_fqn=stage_fqn,
-                package_warehouse=package_warehouse,
-                policy=policy,
+            validation_result = self.get_validation_result(
                 use_scratch_stage=use_scratch_stage,
-                scratch_stage_fqn=scratch_stage_fqn,
+                force=force,
+                interactive=interactive,
             )
 
             # First print warnings, regardless of the outcome of validation
@@ -1177,78 +900,24 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
             if validation_result["status"] == "FAIL":
                 raise SetupScriptFailedValidation()
 
-    def get_validation_result(self, use_scratch_stage: bool = True):
-        model = self._entity_model
-        workspace_ctx = self._workspace_ctx
-        package_name = model.fqn.identifier
-        return self.get_validation_result_static(
-            console=workspace_ctx.console,
-            project_root=workspace_ctx.project_root,
-            deploy_root=workspace_ctx.project_root / model.deploy_root,
-            bundle_root=workspace_ctx.project_root / model.bundle_root,
-            generated_root=(
-                workspace_ctx.project_root / model.deploy_root / model.generated_root
-            ),
-            artifacts=model.artifacts,
-            package_name=package_name,
-            package_role=(model.meta and model.meta.role) or workspace_ctx.default_role,
-            package_distribution=model.distribution,
-            prune=True,
-            recursive=True,
-            paths=[],
-            stage_fqn=f"{package_name}.{model.stage}",
-            package_warehouse=(
-                (model.meta and model.meta.warehouse) or workspace_ctx.default_warehouse
-            ),
-            policy=AllowAlwaysPolicy(),
-            use_scratch_stage=use_scratch_stage,
-            scratch_stage_fqn=f"{package_name}.{model.scratch_stage}",
-        )
-
-    @classmethod
-    def get_validation_result_static(
-        cls,
-        console: AbstractConsole,
-        project_root: Path,
-        deploy_root: Path,
-        bundle_root: Path,
-        generated_root: Path,
-        artifacts: list[PathMapping],
-        package_name: str,
-        package_role: str,
-        package_distribution: str,
-        package_warehouse: str | None,
-        prune: bool,
-        recursive: bool,
-        paths: List[Path] | None,
-        stage_fqn: str,
-        policy: PolicyBase,
-        use_scratch_stage: bool,
-        scratch_stage_fqn: str,
+    def get_validation_result(
+        self, use_scratch_stage: bool, interactive: bool, force: bool
     ):
         """Call system$validate_native_app_setup() to validate deployed Native App setup script."""
+        stage_fqn = self.stage_fqn
         if use_scratch_stage:
-            stage_fqn = scratch_stage_fqn
-            cls.deploy(
-                console=console,
-                project_root=project_root,
-                deploy_root=deploy_root,
-                bundle_root=bundle_root,
-                generated_root=generated_root,
-                artifacts=artifacts,
+            stage_fqn = self.scratch_stage_fqn
+            self._deploy(
                 bundle_map=None,
-                package_name=package_name,
-                package_role=package_role,
-                package_distribution=package_distribution,
-                prune=prune,
-                recursive=recursive,
-                paths=paths,
+                prune=True,
+                recursive=True,
+                paths=[],
                 print_diff=False,
                 validate=False,
-                stage_fqn=stage_fqn,
-                package_warehouse=package_warehouse,
-                post_deploy_hooks=[],
-                policy=policy,
+                stage_fqn=self.scratch_stage_fqn,
+                interactive=interactive,
+                force=force,
+                run_post_deploy_hooks=False,
             )
         prefixed_stage_fqn = StageManager.get_standard_stage_prefix(stage_fqn)
         sql_executor = get_sql_executor()
@@ -1258,7 +927,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
             )
         except ProgrammingError as err:
             if err.errno == DOES_NOT_EXIST_OR_NOT_AUTHORIZED:
-                raise ApplicationPackageDoesNotExistError(package_name)
+                raise ApplicationPackageDoesNotExistError(self.name)
             generic_sql_error_handler(err)
         else:
             if not cursor.rowcount:
@@ -1266,103 +935,112 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
             return json.loads(cursor.fetchone()[0])
         finally:
             if use_scratch_stage:
-                console.step(f"Dropping stage {scratch_stage_fqn}.")
-                with sql_executor.use_role(package_role):
+                self._workspace_ctx.console.step(
+                    f"Dropping stage {self.scratch_stage_fqn}."
+                )
+                with sql_executor.use_role(self.role):
                     sql_executor.execute_query(
-                        f"drop stage if exists {scratch_stage_fqn}"
+                        f"drop stage if exists {self.scratch_stage_fqn}"
                     )
 
-    @classmethod
-    def drop(
-        cls,
-        console: AbstractConsole,
-        package_name: str,
-        package_role: str,
-        force_drop: bool,
+    def resolve_version_info(
+        self,
+        version: str | None,
+        patch: int | None,
+        label: str | None,
+        bundle_map: BundleMap | None,
+        policy: PolicyBase,
+        interactive: bool,
     ):
-        sql_executor = get_sql_executor()
-        needs_confirm = True
-
-        # 1. If existing application package is not found, exit gracefully
-        show_obj_row = cls.get_existing_app_pkg_info(
-            package_name=package_name,
-            package_role=package_role,
-        )
-        if show_obj_row is None:
-            console.warning(
-                f"Role {package_role} does not own any application package with the name {package_name}, or the application package does not exist."
-            )
-            return
-
-        with sql_executor.use_role(package_role):
-            # 2. Check for versions in the application package
-            show_versions_query = f"show versions in application package {package_name}"
-            show_versions_cursor = sql_executor.execute_query(
-                show_versions_query, cursor_class=DictCursor
-            )
-            if show_versions_cursor.rowcount is None:
-                raise SnowflakeSQLExecutionError(show_versions_query)
+        """Determine version name, patch number, and label from CLI provided values and manifest.yml version entry.
+        @param [Optional] version: version name as specified in the command
+        @param [Optional] patch: patch number as specified in the command
+        @param [Optional] label: version/patch label as specified in the command
+        @param [Optional] bundle_map: bundle_map if a deploy_root is prepared. _bundle() is performed otherwise.
+        @param policy: CLI policy
+        @param interactive: True if command is run in interactive mode, otherwise False
+        """
+        console = self._workspace_ctx.console
 
-            if show_versions_cursor.rowcount > 0:
-                # allow dropping a package with versions when --force is set
-                if not force_drop:
-                    raise CouldNotDropApplicationPackageWithVersions(
-                        "Drop versions first, or use --force to override."
-                    )
+        resolved_version = None
+        resolved_patch = None
+        resolved_label = ""
 
-        # 3. Check distribution of the existing application package
-        actual_distribution = cls.get_app_pkg_distribution_in_snowflake(
-            package_name=package_name,
-            package_role=package_role,
-        )
-        if not cls.verify_project_distribution(
-            console=console,
-            package_name=package_name,
-            package_role=package_role,
-            package_distribution=actual_distribution,
-        ):
-            console.warning(
-                f"Dropping application package {package_name} with distribution '{actual_distribution}'."
+        # If version is specified in CLI, no version information from manifest.yml is used (except for comment, we can't control comment as of now).
+        if version is not None:
+            console.message(
+                "Ignoring version information from the application manifest since a version was explicitly specified with the command."
             )
+            resolved_patch = patch
+            resolved_label = label if label is not None else ""
+            resolved_version = version
 
-        # 4. If distribution is internal, check if created by the Snowflake CLI
-        row_comment = show_obj_row[COMMENT_COL]
-        if actual_distribution == INTERNAL_DISTRIBUTION:
-            if row_comment in ALLOWED_SPECIAL_COMMENTS:
-                needs_confirm = False
-            else:
-                if needs_confirmation(needs_confirm, force_drop):
-                    console.warning(
-                        f"Application package {package_name} was not created by Snowflake CLI."
-                    )
+        # When version is not set by CLI, version name is read from manifest.yml. patch and label from CLI will be used, if provided.
         else:
-            if needs_confirmation(needs_confirm, force_drop):
-                console.warning(
-                    f"Application package {package_name} in your Snowflake account has distribution property '{EXTERNAL_DISTRIBUTION}' and could be associated with one or more of your listings on Snowflake Marketplace."
-                )
-
-        if needs_confirmation(needs_confirm, force_drop):
-            should_drop_object = typer.confirm(
+            console.message(
                 dedent(
                     f"""\
-                        Application package details:
-                        Name: {package_name}
-                        Created on: {show_obj_row["created_on"]}
-                        Distribution: {actual_distribution}
-                        Owner: {show_obj_row[OWNER_COL]}
-                        Comment: {show_obj_row[COMMENT_COL]}
-                        Are you sure you want to drop it?
+                        Version was not provided through the Snowflake CLI. Checking version in the manifest.yml instead.
                     """
                 )
             )
-            if not should_drop_object:
-                console.message(f"Did not drop application package {package_name}.")
-                return  # The user desires to keep the application package, therefore exit gracefully
+            if bundle_map is None:
+                self._bundle()
+            (
+                resolved_version,
+                patch_manifest,
+                label_manifest,
+            ) = find_version_info_in_manifest_file(self.deploy_root)
+            if resolved_version is None:
+                raise ClickException(
+                    "Manifest.yml file does not contain a value for the version field."
+                )
 
-        # All validations have passed, drop object
-        drop_generic_object(
-            console=console,
-            object_type="application package",
-            object_name=package_name,
-            role=package_role,
+            # If patch is set in CLI and is also present in manifest.yml with different value, confirmation from
+            # user is required to ignore patch from manifest.yml and proceed with CLI value.
+            if (
+                patch is not None
+                and patch_manifest is not None
+                and patch_manifest != patch
+            ):
+                console.warning(
+                    f"Cannot resolve version. Found patch: {patch_manifest} in manifest.yml which is different from provided patch {patch}."
+                )
+                user_prompt = f"Do you want to ignore patch in manifest.yml and proceed with provided --patch {patch}?"
+                if not policy.should_proceed(user_prompt):
+                    if interactive:
+                        console.message("Not creating a new patch.")
+                        raise typer.Exit(0)
+                    else:
+                        console.message(
+                            "Could not create a new patch non-interactively without --force."
+                        )
+                        raise typer.Exit(1)
+                resolved_patch = patch
+            elif patch is not None:
+                resolved_patch = patch
+            else:
+                resolved_patch = patch_manifest
+
+            # If label is not specified in CLI, label from manifest.yml is used. Even if patch is from CLI.
+            resolved_label = label if label is not None else label_manifest
+
+        # Check if patch needs to throw a bad option error, either if application package does not exist or if version does not exist
+        if resolved_patch is not None:
+            try:
+                if not self.get_existing_version_info(resolved_version):
+                    raise BadOptionUsage(
+                        option_name="patch",
+                        message=f"Cannot create patch {resolved_patch} when version {resolved_version} is not defined in the application package {self.name}. Try again without specifying a patch.",
+                    )
+            except ApplicationPackageDoesNotExistError as app_err:
+                raise BadOptionUsage(
+                    option_name="patch",
+                    message=f"Cannot create patch {resolved_patch} when application package {self.name} does not exist. Try again without specifying a patch.",
+                )
+
+        return VersionInfo(
+            version_name=resolved_version,
+            patch_number=resolved_patch,
+            label=resolved_label,
         )