snowflake-cli 3.2.2__py3-none-any.whl → 3.4.1__py3-none-any.whl

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

@@ -1,18 +1,22 @@
 from __future__ import annotations
 
 import json
+import os
 import re
+from datetime import datetime
+from functools import cached_property
 from pathlib import Path
 from textwrap import dedent
-from typing import List, Literal, Optional, Union
+from typing import Any, List, Literal, Optional, Set, Union
 
 import typer
-from click import BadOptionUsage, ClickException
+from click import BadOptionUsage, ClickException, UsageError
 from pydantic import Field, field_validator
+from snowflake.cli._plugins.connection.util import UIParameter
 from snowflake.cli._plugins.nativeapp.artifacts import (
-    BundleMap,
     VersionInfo,
     build_bundle,
+    find_setup_script_file,
     find_version_info_in_manifest_file,
 )
 from snowflake.cli._plugins.nativeapp.bundle_context import BundleContext
@@ -20,14 +24,19 @@ from snowflake.cli._plugins.nativeapp.codegen.compiler import NativeAppCompiler
 from snowflake.cli._plugins.nativeapp.constants import (
     ALLOWED_SPECIAL_COMMENTS,
     COMMENT_COL,
+    DEFAULT_CHANNEL,
+    DEFAULT_DIRECTIVE,
     EXTERNAL_DISTRIBUTION,
     INTERNAL_DISTRIBUTION,
+    MAX_VERSIONS_IN_RELEASE_CHANNEL,
     NAME_COL,
     OWNER_COL,
     PATCH_COL,
-    SPECIAL_COMMENT,
     VERSION_COL,
 )
+from snowflake.cli._plugins.nativeapp.entities.application_package_child_interface import (
+    ApplicationPackageChildInterface,
+)
 from snowflake.cli._plugins.nativeapp.exceptions import (
     ApplicationPackageAlreadyExistsError,
     ApplicationPackageDoesNotExistError,
@@ -35,6 +44,7 @@ from snowflake.cli._plugins.nativeapp.exceptions import (
     ObjectPropertyNotFoundError,
     SetupScriptFailedValidation,
 )
+from snowflake.cli._plugins.nativeapp.feature_flags import FeatureFlag
 from snowflake.cli._plugins.nativeapp.policy import (
     AllowAlwaysPolicy,
     AskAlwaysPolicy,
@@ -45,36 +55,57 @@ 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.nativeapp.sf_sql_facade import ReleaseChannel, Version
+from snowflake.cli._plugins.nativeapp.utils import needs_confirmation, sanitize_dir_name
+from snowflake.cli._plugins.snowpark.snowpark_entity_model import (
+    FunctionEntityModel,
+    ProcedureEntityModel,
+)
+from snowflake.cli._plugins.stage.diff import DiffResult, compute_stage_diff
+from snowflake.cli._plugins.stage.manager import (
+    DefaultStagePathParts,
+    StageManager,
+    StagePathParts,
+)
+from snowflake.cli._plugins.stage.utils import print_diff_to_console
+from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
+    StreamlitEntityModel,
+)
 from snowflake.cli._plugins.workspace.context import ActionContext
-from snowflake.cli.api.entities.common import EntityBase, get_sql_executor
+from snowflake.cli.api.artifacts.bundle_map import BundleMap
+from snowflake.cli.api.cli_global_context import span
+from snowflake.cli.api.entities.common import (
+    EntityBase,
+    attach_spans_to_entity_actions,
+)
 from snowflake.cli.api.entities.utils import (
     drop_generic_object,
     execute_post_deploy_hooks,
     generic_sql_error_handler,
+    get_sql_executor,
     sync_deploy_root_with_stage,
     validation_item_to_str,
 )
 from snowflake.cli.api.errno import DOES_NOT_EXIST_OR_NOT_AUTHORIZED
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
 from snowflake.cli.api.project.schemas.entities.common import (
-    EntityModelBase,
+    EntityModelBaseWithArtifacts,
     Identifier,
     PostDeployHook,
 )
 from snowflake.cli.api.project.schemas.updatable_model import (
     DiscriminatorField,
     IdentifierField,
+    UpdatableModel,
 )
 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,
+    VALID_IDENTIFIER_REGEX,
     append_test_resource_suffix,
-    extract_schema,
     identifier_to_show_like_pattern,
+    same_identifiers,
+    sql_match,
     to_identifier,
     unquote_identifier,
 )
@@ -82,30 +113,64 @@ from snowflake.cli.api.utils.cursor import find_all_rows
 from snowflake.connector import DictCursor, ProgrammingError
 from snowflake.connector.cursor import SnowflakeCursor
 
+ApplicationPackageChildrenTypes = (
+    StreamlitEntityModel | FunctionEntityModel | ProcedureEntityModel
+)
 
-class ApplicationPackageEntityModel(EntityModelBase):
-    type: Literal["application package"] = DiscriminatorField()  # noqa: A003
-    artifacts: List[Union[PathMapping, str]] = Field(
-        title="List of paths or file source/destination pairs to add to the deploy root",
+
+class ApplicationPackageChildIdentifier(UpdatableModel):
+    schema_: Optional[str] = Field(
+        title="Child entity schema", alias="schema", default=None
+    )
+
+
+class EnsureUsableByField(UpdatableModel):
+    application_roles: Optional[Union[str, Set[str]]] = Field(
+        title="One or more application roles to be granted with the required privileges",
+        default=None,
     )
+
+    @field_validator("application_roles")
+    @classmethod
+    def ensure_app_roles_is_a_set(
+        cls, application_roles: Optional[Union[str, Set[str]]]
+    ) -> Optional[Union[Set[str]]]:
+        if isinstance(application_roles, str):
+            return set([application_roles])
+        return application_roles
+
+
+class ApplicationPackageChildField(UpdatableModel):
+    target: str = Field(title="The key of the entity to include in this package")
+    ensure_usable_by: Optional[EnsureUsableByField] = Field(
+        title="Automatically grant the required privileges on the child object and its schema",
+        default=None,
+    )
+    identifier: ApplicationPackageChildIdentifier = Field(
+        title="Entity identifier", default=None
+    )
+
+
+class ApplicationPackageEntityModel(EntityModelBaseWithArtifacts):
+    type: Literal["application package"] = DiscriminatorField()  # noqa: A003
     bundle_root: Optional[str] = Field(
-        title="Folder at the root of your project where artifacts necessary to perform the bundle step are stored.",
+        title="Folder at the root of your project where artifacts necessary to perform the bundle step are stored",
         default="output/bundle/",
     )
-    deploy_root: Optional[str] = Field(
-        title="Folder at the root of your project where the build step copies the artifacts",
-        default="output/deploy/",
+    children_artifacts_dir: Optional[str] = Field(
+        title="Folder under deploy_root where the child artifacts will be stored",
+        default="_children/",
     )
     generated_root: Optional[str] = Field(
-        title="Subdirectory of the deploy root where files generated by the Snowflake CLI will be written.",
+        title="Subdirectory of the deploy root where files generated by the Snowflake CLI will be written",
         default="__generated/",
     )
     stage: Optional[str] = IdentifierField(
-        title="Identifier of the stage that stores the application artifacts.",
+        title="Identifier of the stage that stores the application artifacts",
         default="app_src.stage",
     )
     scratch_stage: Optional[str] = IdentifierField(
-        title="Identifier of the stage that stores temporary scratch data used by the Snowflake CLI.",
+        title="Identifier of the stage that stores temporary scratch data used by the Snowflake CLI",
         default="app_src.stage_snowflake_cli_scratch",
     )
     distribution: Optional[DistributionOptions] = Field(
@@ -117,6 +182,24 @@ class ApplicationPackageEntityModel(EntityModelBase):
         default="",
     )
 
+    stage_subdirectory: Optional[str] = Field(
+        title="Subfolder in stage to upload the artifacts to, instead of the root of the application package's stage",
+        default="",
+    )
+    children: Optional[List[ApplicationPackageChildField]] = Field(
+        title="Entities that will be bundled and deployed as part of this application package",
+        default=[],
+    )
+
+    @field_validator("children")
+    @classmethod
+    def verify_children_behind_flag(
+        cls, input_value: Optional[List[ApplicationPackageChildField]]
+    ) -> Optional[List[ApplicationPackageChildField]]:
+        if input_value and not FeatureFlag.ENABLE_NATIVE_APP_CHILDREN.is_enabled():
+            raise AttributeError("Application package children are not supported yet")
+        return input_value
+
     @field_validator("identifier")
     @classmethod
     def append_test_resource_suffix_to_identifier(
@@ -130,23 +213,6 @@ class ApplicationPackageEntityModel(EntityModelBase):
             return input_value.model_copy(update=dict(name=with_suffix))
         return with_suffix
 
-    @field_validator("artifacts")
-    @classmethod
-    def transform_artifacts(
-        cls, orig_artifacts: List[Union[PathMapping, str]]
-    ) -> List[PathMapping]:
-        transformed_artifacts = []
-        if orig_artifacts is None:
-            return transformed_artifacts
-
-        for artifact in orig_artifacts:
-            if isinstance(artifact, PathMapping):
-                transformed_artifacts.append(artifact)
-            else:
-                transformed_artifacts.append(PathMapping(src=artifact))
-
-        return transformed_artifacts
-
     @field_validator("stage")
     @classmethod
     def validate_source_stage(cls, input_value: str):
@@ -157,6 +223,7 @@ class ApplicationPackageEntityModel(EntityModelBase):
         return input_value
 
 
+@attach_spans_to_entity_actions(entity_name="app_pkg")
 class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
     """
     A Native App application package.
@@ -168,7 +235,15 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
 
     @property
     def deploy_root(self) -> Path:
-        return self.project_root / self._entity_model.deploy_root
+        return (
+            self.project_root
+            / self._entity_model.deploy_root
+            / self._entity_model.stage_subdirectory
+        )
+
+    @property
+    def children_artifacts_deploy_root(self) -> Path:
+        return self.deploy_root / self._entity_model.children_artifacts_dir
 
     @property
     def bundle_root(self) -> Path:
@@ -195,12 +270,16 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         ) or to_identifier(self._workspace_ctx.default_warehouse)
 
     @property
-    def stage_fqn(self) -> str:
-        return f"{self.name}.{self._entity_model.stage}"
+    def scratch_stage_path(self) -> DefaultStagePathParts:
+        return DefaultStagePathParts.from_fqn(
+            f"{self.name}.{self._entity_model.scratch_stage}"
+        )
 
-    @property
-    def scratch_stage_fqn(self) -> str:
-        return f"{self.name}.{self._entity_model.scratch_stage}"
+    @cached_property
+    def stage_path(self) -> DefaultStagePathParts:
+        stage_fqn = f"{self.name}.{self._entity_model.stage}"
+        subdir = self._entity_model.stage_subdirectory
+        return DefaultStagePathParts.from_fqn(stage_fqn, subdir)
 
     @property
     def post_deploy_hooks(self) -> list[PostDeployHook] | None:
@@ -208,7 +287,24 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         return model.meta and model.meta.post_deploy
 
     def action_bundle(self, action_ctx: ActionContext, *args, **kwargs):
-        return self._bundle()
+        return self._bundle(action_ctx)
+
+    def action_diff(
+        self, action_ctx: ActionContext, print_to_console: bool, *args, **kwargs
+    ):
+        """
+        Compute the diff between the local artifacts and the remote ones on the stage.
+        """
+        bundle_map = self._bundle()
+        diff = compute_stage_diff(
+            local_root=self.deploy_root,
+            stage_path=self.stage_path,
+        )
+
+        if print_to_console:
+            print_diff_to_console(diff, bundle_map)
+
+        return diff
 
     def action_deploy(
         self,
@@ -219,18 +315,18 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         validate: bool,
         interactive: bool,
         force: bool,
-        stage_fqn: Optional[str] = None,
         *args,
         **kwargs,
     ):
         return self._deploy(
+            action_ctx=action_ctx,
             bundle_map=None,
             prune=prune,
             recursive=recursive,
             paths=paths,
             print_diff=True,
             validate=validate,
-            stage_fqn=stage_fqn or self.stage_fqn,
+            stage_path=self.stage_path,
             interactive=interactive,
             force=force,
         )
@@ -248,21 +344,14 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
             )
             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."
-                    )
+        # 2. Check for versions in the application package
+        versions_in_pkg = get_snowflake_facade().show_versions(self.name, self.role)
+        if len(versions_in_pkg) > 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()
@@ -323,6 +412,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         **kwargs,
     ):
         self.validate_setup_script(
+            action_ctx=action_ctx,
             use_scratch_stage=use_scratch_stage,
             interactive=interactive,
             force=force,
@@ -336,15 +426,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         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
+        return get_snowflake_facade().show_versions(self.name, self.role)
 
     def action_version_create(
         self,
@@ -355,9 +437,10 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         skip_git_check: bool,
         interactive: bool,
         force: bool,
+        from_stage: Optional[bool],
         *args,
         **kwargs,
-    ):
+    ) -> VersionInfo:
         """
         Create a version and/or patch for a new or existing application package.
         Always performs a deploy action before creating version or patch.
@@ -372,12 +455,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         else:
             policy = DenyAlwaysPolicy()
 
-        if skip_git_check:
-            git_policy = DenyAlwaysPolicy()
-        else:
-            git_policy = AllowAlwaysPolicy()
-
-        bundle_map = self._bundle()
+        bundle_map = self._bundle(action_ctx)
         resolved_version, resolved_patch, resolved_label = self.resolve_version_info(
             version=version,
             patch=patch,
@@ -387,20 +465,31 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
             interactive=interactive,
         )
 
-        if git_policy.should_proceed():
+        if not skip_git_check:
             self.check_index_changes_in_git_repo(policy=policy, interactive=interactive)
 
-        self._deploy(
-            bundle_map=bundle_map,
-            prune=True,
-            recursive=True,
-            paths=[],
-            print_diff=True,
-            validate=True,
-            stage_fqn=self.stage_fqn,
-            interactive=interactive,
-            force=force,
-        )
+        # if user is asking to create the version from the current stage,
+        # then do not re-deploy the artifacts or touch the stage
+        if from_stage:
+            # verify package exists:
+            if not self.get_existing_app_pkg_info():
+                raise ClickException(
+                    "Cannot create version from stage because the application package does not exist yet. "
+                    "Try removing --from-stage flag or executing `snow app deploy` to deploy the application package first."
+                )
+        else:
+            self._deploy(
+                action_ctx=action_ctx,
+                bundle_map=bundle_map,
+                prune=True,
+                recursive=True,
+                paths=[],
+                print_diff=True,
+                validate=True,
+                stage_path=self.stage_path,
+                interactive=interactive,
+                force=force,
+            )
 
         # Warn if the version exists in a release directive(s)
         try:
@@ -440,12 +529,14 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         # 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.
+            # A new version created automatically has patch 0, we do not need to further increment the patch.
+            return VersionInfo(resolved_version, 0, resolved_label)
 
         # Add a new patch to an existing (old) version
-        self.add_new_patch_to_version(
+        patch = self.add_new_patch_to_version(
             version=resolved_version, patch=resolved_patch, label=resolved_label
         )
+        return VersionInfo(resolved_version, patch, resolved_label)
 
     def action_version_drop(
         self,
@@ -492,7 +583,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
                     """
                 )
             )
-            self._bundle()
+            self._bundle(action_ctx)
             version_info = find_version_info_in_manifest_file(self.deploy_root)
             version = version_info.version_name
             if not version:
@@ -524,20 +615,283 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
                 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)
+        get_snowflake_facade().drop_version_from_package(
+            package_name=self.name, version=version, role=self.role
+        )
 
         console.message(
             f"Version {version} in application package {self.name} dropped successfully."
         )
 
-    def _bundle(self):
+    def _validate_target_accounts(self, accounts: list[str]) -> None:
+        """
+        Validates the target accounts provided by the user.
+        """
+        for account in accounts:
+            if not re.fullmatch(
+                f"{VALID_IDENTIFIER_REGEX}\\.{VALID_IDENTIFIER_REGEX}", account
+            ):
+                raise ClickException(
+                    f"Target account {account} is not in a valid format. Make sure you provide the target account in the format 'org.account'."
+                )
+
+    def get_sanitized_release_channel(
+        self,
+        release_channel: Optional[str],
+        available_release_channels: Optional[list[ReleaseChannel]] = None,
+    ) -> Optional[str]:
+        """
+        Sanitize the release channel name provided by the user and validate it against the available release channels.
+
+        A return value of None indicates that release channels should not be used. Returns None if:
+        - Release channel is not provided
+        - Release channels are not enabled in the application package and the user provided the default release channel
+        """
+        if not release_channel:
+            return None
+
+        if available_release_channels is None:
+            available_release_channels = get_snowflake_facade().show_release_channels(
+                self.name, self.role
+            )
+
+        if not available_release_channels and same_identifiers(
+            release_channel, DEFAULT_CHANNEL
+        ):
+            return None
+
+        self.validate_release_channel(release_channel, available_release_channels)
+        return release_channel
+
+    def validate_release_channel(
+        self,
+        release_channel: str,
+        available_release_channels: Optional[list[ReleaseChannel]] = None,
+    ) -> None:
+        """
+        Validates the release channel provided by the user and make sure it is a valid release channel for the application package.
+        """
+
+        if available_release_channels is None:
+            available_release_channels = get_snowflake_facade().show_release_channels(
+                self.name, self.role
+            )
+        if not available_release_channels:
+            raise UsageError(
+                f"Release channels are not enabled for application package {self.name}."
+            )
+        for channel in available_release_channels:
+            if unquote_identifier(release_channel) == channel["name"]:
+                return
+
+        raise UsageError(
+            f"Release channel {release_channel} is not available in application package {self.name}. "
+            f"Available release channels are: ({', '.join(channel['name'] for channel in available_release_channels)})."
+        )
+
+    def action_release_directive_list(
+        self,
+        action_ctx: ActionContext,
+        release_channel: Optional[str],
+        like: str,
+        *args,
+        **kwargs,
+    ) -> list[dict[str, Any]]:
+        """
+        Get all existing release directives for an application package.
+        Limit the results to a specific release channel, if provided.
+
+        If `like` is provided, only release directives matching the SQL LIKE pattern are listed.
+        """
+        release_channel = self.get_sanitized_release_channel(release_channel)
+
+        release_directives = get_snowflake_facade().show_release_directives(
+            package_name=self.name,
+            role=self.role,
+            release_channel=release_channel,
+        )
+
+        return [
+            directive
+            for directive in release_directives
+            if sql_match(pattern=like, value=directive.get("name", ""))
+        ]
+
+    def action_release_directive_set(
+        self,
+        action_ctx: ActionContext,
+        version: str,
+        patch: int,
+        release_directive: str,
+        release_channel: str,
+        target_accounts: Optional[list[str]],
+        *args,
+        **kwargs,
+    ):
+        """
+        Sets a release directive to the specified version and patch using the specified release channel.
+        Target accounts can only be specified for non-default release directives.
+
+        For non-default release directives, update the existing release directive if target accounts are not provided.
+        """
+        if target_accounts:
+            self._validate_target_accounts(target_accounts)
+
+        if target_accounts and same_identifiers(release_directive, DEFAULT_DIRECTIVE):
+            raise BadOptionUsage(
+                "target_accounts",
+                "Target accounts can only be specified for non-default named release directives.",
+            )
+
+        sanitized_release_channel = self.get_sanitized_release_channel(release_channel)
+
+        get_snowflake_facade().set_release_directive(
+            package_name=self.name,
+            release_directive=release_directive,
+            release_channel=sanitized_release_channel,
+            target_accounts=target_accounts,
+            version=version,
+            patch=patch,
+            role=self.role,
+        )
+
+    def action_release_directive_unset(
+        self,
+        action_ctx: ActionContext,
+        release_directive: str,
+        release_channel: str,
+    ):
+        """
+        Unsets a release directive from the specified release channel.
+        """
+        if same_identifiers(release_directive, DEFAULT_DIRECTIVE):
+            raise ClickException(
+                "Cannot unset default release directive. Please specify a non-default release directive."
+            )
+
+        get_snowflake_facade().unset_release_directive(
+            package_name=self.name,
+            release_directive=release_directive,
+            release_channel=self.get_sanitized_release_channel(release_channel),
+            role=self.role,
+        )
+
+    def action_release_directive_add_accounts(
+        self,
+        action_ctx: ActionContext,
+        release_directive: str,
+        release_channel: str,
+        target_accounts: list[str],
+        *args,
+        **kwargs,
+    ):
+        """
+        Adds target accounts to a release directive.
+        """
+
+        if not target_accounts:
+            raise ClickException("No target accounts provided.")
+
+        self._validate_target_accounts(target_accounts)
+
+        get_snowflake_facade().add_accounts_to_release_directive(
+            package_name=self.name,
+            release_directive=release_directive,
+            release_channel=self.get_sanitized_release_channel(release_channel),
+            target_accounts=target_accounts,
+            role=self.role,
+        )
+
+    def action_release_directive_remove_accounts(
+        self,
+        action_ctx: ActionContext,
+        release_directive: str,
+        release_channel: str,
+        target_accounts: list[str],
+        *args,
+        **kwargs,
+    ):
+        """
+        Removes target accounts from a release directive.
+        """
+
+        if not target_accounts:
+            raise ClickException("No target accounts provided.")
+
+        self._validate_target_accounts(target_accounts)
+
+        get_snowflake_facade().remove_accounts_from_release_directive(
+            package_name=self.name,
+            release_directive=release_directive,
+            release_channel=self.get_sanitized_release_channel(release_channel),
+            target_accounts=target_accounts,
+            role=self.role,
+        )
+
+    def _print_channel_to_console(self, channel: ReleaseChannel) -> None:
+        """
+        Prints the release channel details to the console.
+        """
+        console = self._workspace_ctx.console
+
+        console.message(f"""[bold]{channel["name"]}[/bold]""")
+        accounts_list: Optional[list[str]] = channel["targets"].get("accounts")
+        target_accounts = (
+            f"({', '.join(accounts_list)})"
+            if accounts_list is not None
+            else "ALL ACCOUNTS"
+        )
+
+        formatted_created_on = (
+            channel["created_on"].astimezone().strftime("%Y-%m-%d %H:%M:%S.%f %Z")
+            if channel["created_on"]
+            else ""
+        )
+
+        formatted_updated_on = (
+            channel["updated_on"].astimezone().strftime("%Y-%m-%d %H:%M:%S.%f %Z")
+            if channel["updated_on"]
+            else ""
+        )
+        with console.indented():
+            console.message(f"Description: {channel['description']}")
+            console.message(f"Versions: ({', '.join(channel['versions'])})")
+            console.message(f"Created on: {formatted_created_on}")
+            console.message(f"Updated on: {formatted_updated_on}")
+            console.message(f"Target accounts: {target_accounts}")
+
+    def action_release_channel_list(
+        self,
+        action_ctx: ActionContext,
+        release_channel: Optional[str],
+        *args,
+        **kwargs,
+    ) -> list[ReleaseChannel]:
+        """
+        Get all existing release channels for an application package.
+        If `release_channel` is provided, only the specified release channel is listed.
+        """
+        console = self._workspace_ctx.console
+        available_channels = get_snowflake_facade().show_release_channels(
+            self.name, self.role
+        )
+
+        filtered_channels = [
+            channel
+            for channel in available_channels
+            if release_channel is None
+            or unquote_identifier(release_channel) == channel["name"]
+        ]
+
+        if not filtered_channels:
+            console.message("No release channels found.")
+        else:
+            for channel in filtered_channels:
+                self._print_channel_to_console(channel)
+
+        return filtered_channels
+
+    def _bundle(self, action_ctx: ActionContext = None):
         model = self._entity_model
         bundle_map = build_bundle(self.project_root, self.deploy_root, model.artifacts)
         bundle_context = BundleContext(
@@ -550,17 +904,391 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         )
         compiler = NativeAppCompiler(bundle_context)
         compiler.compile_artifacts()
+
+        if self._entity_model.children:
+            # Bundle children and append their SQL to setup script
+            # TODO Consider re-writing the logic below as a processor
+            children_sql = self._bundle_children(action_ctx=action_ctx)
+            setup_file_path = find_setup_script_file(deploy_root=self.deploy_root)
+            with open(setup_file_path, "r", encoding="utf-8") as file:
+                existing_setup_script = file.read()
+            if setup_file_path.is_symlink():
+                setup_file_path.unlink()
+            with open(setup_file_path, "w", encoding="utf-8") as file:
+                file.write(existing_setup_script)
+                file.write("\n-- AUTO GENERATED CHILDREN SECTION\n")
+                file.write("\n".join(children_sql))
+                file.write("\n")
+
         return bundle_map
 
+    def action_release_channel_add_accounts(
+        self,
+        action_ctx: ActionContext,
+        release_channel: str,
+        target_accounts: list[str],
+        *args,
+        **kwargs,
+    ):
+        """
+        Adds target accounts to a release channel.
+        """
+
+        if not target_accounts:
+            raise ClickException("No target accounts provided.")
+
+        self.validate_release_channel(release_channel)
+        self._validate_target_accounts(target_accounts)
+
+        get_snowflake_facade().add_accounts_to_release_channel(
+            package_name=self.name,
+            release_channel=release_channel,
+            target_accounts=target_accounts,
+            role=self.role,
+        )
+
+    def action_release_channel_remove_accounts(
+        self,
+        action_ctx: ActionContext,
+        release_channel: str,
+        target_accounts: list[str],
+        *args,
+        **kwargs,
+    ):
+        """
+        Removes target accounts from a release channel.
+        """
+
+        if not target_accounts:
+            raise ClickException("No target accounts provided.")
+
+        self.validate_release_channel(release_channel)
+        self._validate_target_accounts(target_accounts)
+
+        get_snowflake_facade().remove_accounts_from_release_channel(
+            package_name=self.name,
+            release_channel=release_channel,
+            target_accounts=target_accounts,
+            role=self.role,
+        )
+
+    def action_release_channel_set_accounts(
+        self,
+        action_ctx: ActionContext,
+        release_channel: str,
+        target_accounts: list[str],
+        *args,
+        **kwargs,
+    ):
+        """
+        Sets target accounts for a release channel.
+        """
+
+        if not target_accounts:
+            raise ClickException("No target accounts provided.")
+
+        self.validate_release_channel(release_channel)
+        self._validate_target_accounts(target_accounts)
+
+        get_snowflake_facade().set_accounts_for_release_channel(
+            package_name=self.name,
+            release_channel=release_channel,
+            target_accounts=target_accounts,
+            role=self.role,
+        )
+
+    def action_release_channel_add_version(
+        self,
+        action_ctx: ActionContext,
+        release_channel: str,
+        version: str,
+        *args,
+        **kwargs,
+    ):
+        """
+        Adds a version to a release channel.
+        """
+
+        self.validate_release_channel(release_channel)
+        get_snowflake_facade().add_version_to_release_channel(
+            package_name=self.name,
+            release_channel=release_channel,
+            version=version,
+            role=self.role,
+        )
+
+    def action_release_channel_remove_version(
+        self,
+        action_ctx: ActionContext,
+        release_channel: str,
+        version: str,
+        *args,
+        **kwargs,
+    ):
+        """
+        Removes a version from a release channel.
+        """
+
+        self.validate_release_channel(release_channel)
+        get_snowflake_facade().remove_version_from_release_channel(
+            package_name=self.name,
+            release_channel=release_channel,
+            version=version,
+            role=self.role,
+        )
+
+    def _find_version_with_no_recent_update(
+        self, versions_info: list[Version], free_versions: set[str]
+    ) -> Optional[str]:
+        """
+        Finds the version with the oldest created_on date from the free versions.
+        """
+
+        if not free_versions:
+            return None
+
+        # map of versionId to last Updated Date. Last Updated Date is based on patch creation date.
+        last_updated_map: dict[str, datetime] = {}
+        for version_info in versions_info:
+            last_updated_value = last_updated_map.get(version_info["version"], None)
+            if (
+                not last_updated_value
+                or version_info["created_on"] > last_updated_value
+            ):
+                last_updated_map[version_info["version"]] = version_info["created_on"]
+
+        oldest_version = None
+        oldest_version_last_updated_on = None
+
+        for version in free_versions:
+            last_updated = last_updated_map[version]
+            if not oldest_version or last_updated < oldest_version_last_updated_on:
+                oldest_version = version
+                oldest_version_last_updated_on = last_updated
+
+        return oldest_version
+
+    def action_publish(
+        self,
+        action_ctx: ActionContext,
+        version: Optional[str],
+        patch: Optional[int],
+        release_channel: Optional[str],
+        release_directive: str,
+        interactive: bool,
+        force: bool,
+        *args,
+        create_version: bool = False,
+        from_stage: bool = False,
+        label: Optional[str] = None,
+        **kwargs,
+    ) -> VersionInfo:
+        """
+        Publishes a version and a patch to a release directive of a release channel.
+
+        The version is first added to the release channel,
+        and then the release directive is set to the version and patch provided.
+
+        If the number of versions in a release channel exceeds the maximum allowable versions,
+        the user is prompted to remove an existing version to make space for the new version.
+        """
+        if force:
+            policy = AllowAlwaysPolicy()
+        elif interactive:
+            policy = AskAlwaysPolicy()
+        else:
+            policy = DenyAlwaysPolicy()
+
+        if from_stage and not create_version:
+            raise UsageError(
+                "--from-stage flag can only be used with --create-version flag."
+            )
+        if label is not None and not create_version:
+            raise UsageError("--label can only be used with --create-version flag.")
+
+        console = self._workspace_ctx.console
+        if create_version:
+            result = self.action_version_create(
+                action_ctx=action_ctx,
+                version=version,
+                patch=patch,
+                label=label,
+                skip_git_check=True,
+                interactive=interactive,
+                force=force,
+                from_stage=from_stage,
+            )
+            version = result.version_name
+            patch = result.patch_number
+
+        if version is None:
+            raise UsageError(
+                "Please provide a version using --version or use --create-version flag to create a version based on the manifest file."
+            )
+        if patch is None:
+            raise UsageError(
+                "Please provide a patch number using --patch or use --create-version flag to auto create a patch."
+            )
+
+        versions_info = get_snowflake_facade().show_versions(self.name, self.role)
+
+        available_patches = [
+            version_info["patch"]
+            for version_info in versions_info
+            if version_info["version"] == unquote_identifier(version)
+        ]
+
+        if not available_patches:
+            raise ClickException(
+                f"Version {version} does not exist in application package {self.name}. Use --create-version flag to create a new version."
+            )
+
+        if patch not in available_patches:
+            raise ClickException(
+                f"Patch {patch} does not exist for version {version} in application package {self.name}. Use --create-version flag to add a new patch."
+            )
+
+        available_release_channels = get_snowflake_facade().show_release_channels(
+            self.name, self.role
+        )
+
+        release_channel = self.get_sanitized_release_channel(
+            release_channel, available_release_channels
+        )
+
+        if release_channel:
+            release_channel_info = {}
+            for channel_info in available_release_channels:
+                if channel_info["name"] == unquote_identifier(release_channel):
+                    release_channel_info = channel_info
+                    break
+
+            versions_in_channel = release_channel_info["versions"]
+            if unquote_identifier(version) not in release_channel_info["versions"]:
+                if len(versions_in_channel) >= MAX_VERSIONS_IN_RELEASE_CHANNEL:
+                    # If we hit the maximum allowable versions in a release channel, we need to remove one version to make space for the new version
+                    all_release_directives = (
+                        get_snowflake_facade().show_release_directives(
+                            package_name=self.name,
+                            role=self.role,
+                            release_channel=release_channel,
+                        )
+                    )
+
+                    # check which versions are attached to any release directive
+                    targeted_versions = {d["version"] for d in all_release_directives}
+
+                    free_versions = {
+                        v for v in versions_in_channel if v not in targeted_versions
+                    }
+
+                    if not free_versions:
+                        raise ClickException(
+                            f"Maximum number of versions in release channel {release_channel} reached. Cannot add more versions."
+                        )
+
+                    version_to_remove = self._find_version_with_no_recent_update(
+                        versions_info, free_versions
+                    )
+                    user_prompt = f"Maximum number of versions in release channel reached. Would you like to remove version {version_to_remove} to make space for version {version}?"
+                    if not policy.should_proceed(user_prompt):
+                        raise ClickException(
+                            "Cannot proceed with publishing the new version. Please remove an existing version from the release channel to make space for the new version, or use --force to automatically clean up unused versions."
+                        )
+
+                    console.warning(
+                        f"Maximum number of versions in release channel reached. Removing version {version_to_remove} from release_channel {release_channel} to make space for version {version}."
+                    )
+                    get_snowflake_facade().remove_version_from_release_channel(
+                        package_name=self.name,
+                        release_channel=release_channel,
+                        version=version_to_remove,
+                        role=self.role,
+                    )
+
+                get_snowflake_facade().add_version_to_release_channel(
+                    package_name=self.name,
+                    release_channel=release_channel,
+                    version=version,
+                    role=self.role,
+                )
+
+        get_snowflake_facade().set_release_directive(
+            package_name=self.name,
+            release_directive=release_directive,
+            release_channel=release_channel,
+            target_accounts=None,
+            version=version,
+            patch=patch,
+            role=self.role,
+        )
+        return VersionInfo(version, patch, None)
+
+    def _bundle_children(self, action_ctx: ActionContext) -> List[str]:
+        # Create _children directory
+        children_artifacts_dir = self.children_artifacts_deploy_root
+        os.makedirs(children_artifacts_dir)
+        children_sql = []
+        for child in self._entity_model.children:
+            # Create child sub directory
+            child_artifacts_dir = children_artifacts_dir / sanitize_dir_name(
+                child.target
+            )
+            try:
+                os.makedirs(child_artifacts_dir)
+            except FileExistsError:
+                raise ClickException(
+                    f"Could not create sub-directory at {child_artifacts_dir}. Make sure child entity names do not collide with each other."
+                )
+            child_entity: ApplicationPackageChildInterface = action_ctx.get_entity(
+                child.target
+            )
+            child_entity.bundle(child_artifacts_dir)
+            app_role = (
+                to_identifier(
+                    child.ensure_usable_by.application_roles.pop()  # TODO Support more than one application role
+                )
+                if child.ensure_usable_by and child.ensure_usable_by.application_roles
+                else None
+            )
+            child_schema = (
+                to_identifier(child.identifier.schema_)
+                if child.identifier and child.identifier.schema_
+                else None
+            )
+            children_sql.append(
+                child_entity.get_deploy_sql(
+                    artifacts_dir=child_artifacts_dir.relative_to(self.deploy_root),
+                    schema=child_schema,
+                    # TODO Allow users to override the hard-coded value for specific children
+                    replace=True,
+                )
+            )
+            if app_role:
+                children_sql.append(
+                    f"CREATE APPLICATION ROLE IF NOT EXISTS {app_role};"
+                )
+                if child_schema:
+                    children_sql.append(
+                        f"GRANT USAGE ON SCHEMA {child_schema} TO APPLICATION ROLE {app_role};"
+                    )
+                children_sql.append(
+                    child_entity.get_usage_grant_sql(
+                        app_role=app_role, schema=child_schema
+                    )
+                )
+        return children_sql
+
     def _deploy(
         self,
+        action_ctx: ActionContext,
         bundle_map: BundleMap | None,
         prune: bool,
         recursive: bool,
         paths: list[Path],
         print_diff: bool,
         validate: bool,
-        stage_fqn: str,
+        stage_path: StagePathParts,
         interactive: bool,
         force: bool,
         run_post_deploy_hooks: bool = True,
@@ -575,10 +1303,10 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
             policy = DenyAlwaysPolicy()
 
         console = workspace_ctx.console
-        stage_fqn = stage_fqn or self.stage_fqn
+        stage_path = stage_path or self.stage_path
 
         # 1. Create a bundle if one wasn't passed in
-        bundle_map = bundle_map or self._bundle()
+        bundle_map = bundle_map or self._bundle(action_ctx)
 
         # 2. Create an empty application package, if none exists
         try:
@@ -590,17 +1318,15 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
 
         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=self.deploy_root,
                 package_name=self.name,
-                stage_schema=stage_schema,
                 bundle_map=bundle_map,
                 role=self.role,
                 prune=prune,
                 recursive=recursive,
-                stage_fqn=stage_fqn,
+                stage_path=stage_path,
                 local_paths_to_sync=paths,
                 print_diff=print_diff,
             )
@@ -610,6 +1336,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
 
         if validate:
             self.validate_setup_script(
+                action_ctx=action_ctx,
                 use_scratch_stage=False,
                 interactive=interactive,
                 force=force,
@@ -657,7 +1384,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         It executes a 'show release directives in application package' query and returns the filtered results, if they exist.
         """
         release_directives = get_snowflake_facade().show_release_directives(
-            self.name, self.role
+            package_name=self.name, role=self.role
         )
         return [
             directive
@@ -678,7 +1405,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         get_snowflake_facade().create_version_in_package(
             role=self.role,
             package_name=self.name,
-            stage_fqn=self.stage_fqn,
+            path_to_version_directory=self.stage_path.full_path,
             version=version,
             label=label,
         )
@@ -688,9 +1415,10 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
 
     def add_new_patch_to_version(
         self, version: str, patch: int | None = None, label: str | None = None
-    ):
+    ) -> int:
         """
         Add a new patch, optionally a custom one, to an existing version in an application package.
+        Returns the patch number of the newly created patch.
         """
         console = self._workspace_ctx.console
 
@@ -702,7 +1430,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         new_patch = get_snowflake_facade().add_patch_to_package_version(
             role=self.role,
             package_name=self.name,
-            stage_fqn=self.stage_fqn,
+            path_to_version_directory=self.stage_path.full_path,
             version=version,
             patch=patch,
             label=label,
@@ -710,6 +1438,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         console.message(
             f"Patch {new_patch}{with_label_prompt} created for version {version} defined in application package {self.name}."
         )
+        return new_patch
 
     def check_index_changes_in_git_repo(
         self, policy: PolicyBase, interactive: bool
@@ -795,7 +1524,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
     ) -> 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.
+        is the same as the attribute specified in project definition file.
         """
         model = self._entity_model
         workspace_ctx = self._workspace_ctx
@@ -818,6 +1547,28 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
             return False
         return True
 
+    def _get_enable_release_channels_flag(self) -> Optional[bool]:
+        """
+        Returns the requested value of enable_release_channels flag for the application package.
+        It retrieves the value from the configuration file and checks that the feature is enabled in the account.
+        If return value is None, it means do not explicitly set the flag.
+        """
+        feature_flag_from_config = FeatureFlag.ENABLE_RELEASE_CHANNELS.get_value()
+        feature_enabled_in_account = (
+            get_snowflake_facade().get_ui_parameter(
+                UIParameter.NA_FEATURE_RELEASE_CHANNELS, "ENABLED"
+            )
+            == "ENABLED"
+        )
+
+        if feature_flag_from_config is not None and not feature_enabled_in_account:
+            self._workspace_ctx.console.warning(
+                f"Ignoring feature flag {FeatureFlag.ENABLE_RELEASE_CHANNELS.name} because release channels are not enabled in the current account."
+            )
+            return None
+
+        return feature_flag_from_config
+
     def create_app_package(self) -> None:
         """
         Creates the application package with our up-to-date stage if none exists.
@@ -845,21 +1596,23 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
                 if row_comment not in ALLOWED_SPECIAL_COMMENTS:
                     raise ApplicationPackageAlreadyExistsError(self.name)
 
+            # 4. Update the application package with setting enable_release_channels if necessary
+            get_snowflake_facade().alter_application_package_properties(
+                package_name=self.name,
+                enable_release_channels=self._get_enable_release_channels_flag(),
+                role=self.role,
+            )
+
             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(self.role):
-            console.step(f"Creating new application package {self.name} in account.")
-            sql_executor.execute_query(
-                dedent(
-                    f"""\
-                    create application package {self.name}
-                        comment = {SPECIAL_COMMENT}
-                        distribution = {model.distribution}
-                """
-                )
-            )
+        console.step(f"Creating new application package {self.name} in account.")
+        get_snowflake_facade().create_application_package(
+            role=self.role,
+            enable_release_channels=self._get_enable_release_channels_flag(),
+            distribution=model.distribution,
+            package_name=self.name,
+        )
 
     def execute_post_deploy_hooks(self):
         execute_post_deploy_hooks(
@@ -873,7 +1626,11 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         )
 
     def validate_setup_script(
-        self, use_scratch_stage: bool, interactive: bool, force: bool
+        self,
+        action_ctx: ActionContext,
+        use_scratch_stage: bool,
+        interactive: bool,
+        force: bool,
     ):
         workspace_ctx = self._workspace_ctx
         console = workspace_ctx.console
@@ -881,6 +1638,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         """Validates Native App setup script SQL."""
         with console.phase(f"Validating Snowflake Native App setup script."):
             validation_result = self.get_validation_result(
+                action_ctx=action_ctx,
                 use_scratch_stage=use_scratch_stage,
                 force=force,
                 interactive=interactive,
@@ -900,26 +1658,35 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
             if validation_result["status"] == "FAIL":
                 raise SetupScriptFailedValidation()
 
+    @span("validate_setup_script")
     def get_validation_result(
-        self, use_scratch_stage: bool, interactive: bool, force: bool
+        self,
+        action_ctx: ActionContext,
+        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
+        stage_path = self.stage_path
         if use_scratch_stage:
-            stage_fqn = self.scratch_stage_fqn
+            stage_path = self.scratch_stage_path
             self._deploy(
+                action_ctx=action_ctx,
                 bundle_map=None,
                 prune=True,
                 recursive=True,
                 paths=[],
                 print_diff=False,
                 validate=False,
-                stage_fqn=self.scratch_stage_fqn,
+                stage_path=stage_path,
                 interactive=interactive,
                 force=force,
                 run_post_deploy_hooks=False,
             )
-        prefixed_stage_fqn = StageManager.get_standard_stage_prefix(stage_fqn)
+        prefixed_stage_fqn = StageManager.get_standard_stage_prefix(
+            stage_path.full_path
+        )
+
         sql_executor = get_sql_executor()
         try:
             cursor = sql_executor.execute_query(
@@ -936,11 +1703,11 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         finally:
             if use_scratch_stage:
                 self._workspace_ctx.console.step(
-                    f"Dropping stage {self.scratch_stage_fqn}."
+                    f"Dropping stage {self.scratch_stage_path.stage}."
                 )
                 with sql_executor.use_role(self.role):
                     sql_executor.execute_query(
-                        f"drop stage if exists {self.scratch_stage_fqn}"
+                        f"drop stage if exists {self.scratch_stage_path.stage}"
                     )
 
     def resolve_version_info(
@@ -951,7 +1718,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         bundle_map: BundleMap | None,
         policy: PolicyBase,
         interactive: bool,
-    ):
+    ) -> VersionInfo:
         """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
@@ -959,12 +1726,14 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         @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
+
+        @return VersionInfo: version_name, patch_number, label resolved from CLI and manifest.yml
         """
         console = self._workspace_ctx.console
 
         resolved_version = None
         resolved_patch = None
-        resolved_label = ""
+        resolved_label = None
 
         # 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:
@@ -972,7 +1741,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
                 "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_label = label
             resolved_version = version
 
         # When version is not set by CLI, version name is read from manifest.yml. patch and label from CLI will be used, if provided.
@@ -1026,17 +1795,18 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
             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:
+        # If patch is 0 and version does not exist, it is a valid case, because patch 0 is the first patch in a version.
+        if resolved_patch:
             try:
-                if not self.get_existing_version_info(resolved_version):
+                if not self.get_existing_version_info(to_identifier(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.",
+                        message=f"Version {resolved_version} is not defined in the application package {self.name}. Try again with a patch of 0 or without specifying any 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.",
+                    message=f"Application package {self.name} does not exist yet. Try again with a patch of 0 or without specifying any patch.",
                 )
 
         return VersionInfo(