snowflake-cli-labs 2.3.0rc1__py3-none-any.whl → 2.4.0rc0__py3-none-any.whl

snowflake/cli/plugins/nativeapp/manager.py

@@ -5,9 +5,10 @@ from abc import ABC, abstractmethod
 from functools import cached_property
 from pathlib import Path
 from textwrap import dedent
-from typing import List, Optional
+from typing import List, Optional, TypedDict
 
 import jinja2
+from click import ClickException
 from snowflake.cli.api.console import cli_console as cc
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
 from snowflake.cli.api.project.definition import (
@@ -24,13 +25,15 @@ from snowflake.cli.api.project.util import (
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.cli.plugins.connection.util import make_snowsight_url
 from snowflake.cli.plugins.nativeapp.artifacts import (
-    ArtifactDeploymentMap,
     ArtifactMapping,
+    BundleMap,
     build_bundle,
     resolve_without_follow,
-    source_path_to_deploy_path,
     translate_artifact,
 )
+from snowflake.cli.plugins.nativeapp.codegen.compiler import (
+    NativeAppCompiler,
+)
 from snowflake.cli.plugins.nativeapp.constants import (
     ALLOWED_SPECIAL_COMMENTS,
     COMMENT_COL,
@@ -47,6 +50,7 @@ from snowflake.cli.plugins.nativeapp.exceptions import (
     MissingPackageScriptError,
     UnexpectedOwnerError,
 )
+from snowflake.cli.plugins.nativeapp.feature_flags import FeatureFlag
 from snowflake.cli.plugins.nativeapp.utils import verify_exists, verify_no_directories
 from snowflake.cli.plugins.stage.diff import (
     DiffResult,
@@ -59,6 +63,8 @@ from snowflake.cli.plugins.stage.diff import (
 from snowflake.connector import ProgrammingError
 from snowflake.connector.cursor import DictCursor
 
+ApplicationOwnedObject = TypedDict("ApplicationOwnedObject", {"name": str, "type": str})
+
 
 def generic_sql_error_handler(
     err: ProgrammingError, role: Optional[str] = None, warehouse: Optional[str] = None
@@ -159,6 +165,10 @@ class NativeAppManager(SqlExecutionMixin):
     def deploy_root(self) -> Path:
         return Path(self.project_root, self.definition.deploy_root)
 
+    @cached_property
+    def generated_root(self) -> Path:
+        return Path(self.deploy_root, self.definition.generated_root)
+
     @cached_property
     def package_scripts(self) -> List[str]:
         """
@@ -305,11 +315,20 @@ class NativeAppManager(SqlExecutionMixin):
             return False
         return True
 
-    def build_bundle(self) -> ArtifactDeploymentMap:
+    def build_bundle(self) -> BundleMap:
         """
         Populates the local deploy root from artifact sources.
         """
-        return build_bundle(self.project_root, self.deploy_root, self.artifacts)
+        mapped_files = build_bundle(self.project_root, self.deploy_root, self.artifacts)
+        if FeatureFlag.ENABLE_SETUP_SCRIPT_GENERATION.is_enabled():
+            compiler = NativeAppCompiler(
+                project_definition=self._project_definition,
+                project_root=self.project_root,
+                deploy_root=self.deploy_root,
+                generated_root=self.generated_root,
+            )
+            compiler.compile_artifacts()
+        return mapped_files
 
     def sync_deploy_root_with_stage(
         self,
@@ -317,7 +336,7 @@ class NativeAppManager(SqlExecutionMixin):
         prune: bool,
         recursive: bool,
         local_paths_to_sync: List[Path] | None = None,
-        mapped_files: Optional[ArtifactDeploymentMap] = None,
+        bundle_map: Optional[BundleMap] = None,
     ) -> DiffResult:
         """
         Ensures that the files on our remote stage match the artifacts we have in
@@ -329,7 +348,7 @@ class NativeAppManager(SqlExecutionMixin):
             recursive (bool): Whether to traverse directories recursively.
             local_paths_to_sync (List[Path], optional): List of local paths to sync. Defaults to None to sync all
              local paths. Note that providing an empty list here is equivalent to None.
-            mapped_files: the file mapping computed during the `bundle` step. Required when local_paths_to_sync is
+            bundle_map: the artifact mapping computed during the `bundle` step. Required when local_paths_to_sync is
              provided.
 
         Returns:
@@ -359,7 +378,7 @@ class NativeAppManager(SqlExecutionMixin):
 
         files_not_removed = []
         if local_paths_to_sync:
-            assert mapped_files is not None
+            assert bundle_map is not None
 
             # Deploying specific files/directories
             resolved_paths_to_sync = [
@@ -367,13 +386,17 @@ class NativeAppManager(SqlExecutionMixin):
             ]
             if not recursive:
                 verify_no_directories(resolved_paths_to_sync)
-            deploy_paths_to_sync = [
-                source_path_to_deploy_path(p, mapped_files)
-                for p in resolved_paths_to_sync
-            ]
-            verify_exists(deploy_paths_to_sync)
+
+            deploy_paths_to_sync = []
+            for resolved_path in resolved_paths_to_sync:
+                verify_exists(resolved_path)
+                deploy_paths = bundle_map.to_deploy_paths(resolved_path)
+                if not deploy_paths:
+                    raise ClickException(f"No artifact found for {resolved_path}")
+                deploy_paths_to_sync.extend(deploy_paths)
+
             stage_paths_to_sync = _get_stage_paths_to_sync(
-                deploy_paths_to_sync, self.deploy_root.resolve()
+                deploy_paths_to_sync, resolve_without_follow(self.deploy_root)
             )
             diff = preserve_from_diff(diff, stage_paths_to_sync)
         else:
@@ -429,6 +452,16 @@ class NativeAppManager(SqlExecutionMixin):
                 "application packages", self.package_name, name_col=NAME_COL
             )
 
+    def get_objects_owned_by_application(self) -> List[ApplicationOwnedObject]:
+        """
+        Returns all application objects owned by this application.
+        """
+        with self.use_role(self.app_role):
+            results = self._execute_query(
+                f"show objects owned by application {self.app_name}"
+            ).fetchall()
+            return [{"name": row[1], "type": row[2]} for row in results]
+
     def get_snowsight_url(self) -> str:
         """Returns the URL that can be used to visit this app via Snowsight."""
         name = unquote_identifier(self.app_name)
@@ -522,7 +555,7 @@ class NativeAppManager(SqlExecutionMixin):
         prune: bool,
         recursive: bool,
         local_paths_to_sync: List[Path] | None = None,
-        mapped_files: Optional[ArtifactDeploymentMap] = None,
+        bundle_map: Optional[BundleMap] = None,
     ) -> DiffResult:
         """app deploy process"""
 
@@ -535,7 +568,7 @@ class NativeAppManager(SqlExecutionMixin):
 
             # 3. Upload files from deploy root local folder to the above stage
             diff = self.sync_deploy_root_with_stage(
-                self.package_role, prune, recursive, local_paths_to_sync, mapped_files
+                self.package_role, prune, recursive, local_paths_to_sync, bundle_map
             )
 
         return diff

snowflake/cli/plugins/nativeapp/policy.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
 from typing import Optional
 

snowflake/cli/plugins/nativeapp/run_processor.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pathlib import Path
 from textwrap import dedent
 from typing import Optional
@@ -7,10 +9,16 @@ from click import UsageError
 from snowflake.cli.api.console import cli_console as cc
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
 from snowflake.cli.api.project.schemas.native_app.native_app import NativeApp
+from snowflake.cli.api.project.util import (
+    identifier_to_show_like_pattern,
+    unquote_identifier,
+)
+from snowflake.cli.api.utils.cursor import find_all_rows
 from snowflake.cli.plugins.nativeapp.constants import (
     ALLOWED_SPECIAL_COMMENTS,
     COMMENT_COL,
     LOOSE_FILES_MAGIC_VERSION,
+    PATCH_COL,
     SPECIAL_COMMENT,
     VERSION_COL,
 )
@@ -28,7 +36,7 @@ from snowflake.cli.plugins.nativeapp.policy import PolicyBase
 from snowflake.cli.plugins.stage.diff import DiffResult
 from snowflake.cli.plugins.stage.manager import StageManager
 from snowflake.connector import ProgrammingError
-from snowflake.connector.cursor import SnowflakeCursor
+from snowflake.connector.cursor import DictCursor, SnowflakeCursor
 
 UPGRADE_RESTRICTION_CODES = {93044, 93055, 93045, 93046}
 
@@ -134,24 +142,34 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
 
     def get_existing_version_info(self, version: str) -> Optional[dict]:
         """
-        Get an existing version, if defined, by the same name in an application package.
-        It executes a 'show versions like ... in application package' query and returns the result as single row, if one exists.
+        Get the latest patch on an existing version by name in the application package.
+        Executes 'show versions like ... in application package' query and returns
+        the latest patch in the version as a single row, if one exists. Otherwise,
+        returns None.
         """
         with self.use_role(self.package_role):
             try:
-                version_obj = self.show_specific_object(
-                    "versions",
-                    version,
-                    name_col=VERSION_COL,
-                    in_clause=f"in application package {self.package_name}",
+                query = f"show versions like {identifier_to_show_like_pattern(version)} in application package {self.package_name}"
+                cursor = self._execute_query(query, cursor_class=DictCursor)
+
+                if cursor.rowcount is None:
+                    raise SnowflakeSQLExecutionError(query)
+
+                matching_rows = find_all_rows(
+                    cursor, lambda row: row[VERSION_COL] == unquote_identifier(version)
                 )
+
+                if not matching_rows:
+                    return None
+
+                return max(matching_rows, key=lambda row: row[PATCH_COL])
+
             except ProgrammingError as err:
                 if err.msg.__contains__("does not exist or not authorized"):
                     raise ApplicationPackageDoesNotExistError(self.package_name)
                 else:
                     generic_sql_error_handler(err=err, role=self.package_role)
-
-            return version_obj
+                    return None
 
     def drop_application_before_upgrade(self, policy: PolicyBase, is_interactive: bool):
         """

snowflake/cli/plugins/nativeapp/teardown_processor.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 from pathlib import Path
 from textwrap import dedent
-from typing import Dict
+from typing import Dict, Optional
 
 import typer
 from snowflake.cli.api.console import cli_console as cc
@@ -16,11 +18,14 @@ from snowflake.cli.plugins.nativeapp.exceptions import (
     CouldNotDropApplicationPackageWithVersions,
 )
 from snowflake.cli.plugins.nativeapp.manager import (
+    ApplicationOwnedObject,
     NativeAppCommandProcessor,
     NativeAppManager,
     ensure_correct_owner,
 )
-from snowflake.cli.plugins.nativeapp.utils import needs_confirmation
+from snowflake.cli.plugins.nativeapp.utils import (
+    needs_confirmation,
+)
 from snowflake.connector.cursor import DictCursor
 
 
@@ -28,13 +33,17 @@ class NativeAppTeardownProcessor(NativeAppManager, NativeAppCommandProcessor):
     def __init__(self, project_definition: Dict, project_root: Path):
         super().__init__(project_definition, project_root)
 
-    def drop_generic_object(self, object_type: str, object_name: str, role: str):
+    def drop_generic_object(
+        self, object_type: str, object_name: str, role: str, cascade: bool = False
+    ):
         """
         Drop object using the given role.
         """
         with self.use_role(role):
             cc.step(f"Dropping {object_type} {object_name} now.")
             drop_query = f"drop {object_type} {object_name}"
+            if cascade:
+                drop_query += " cascade"
             try:
                 self._execute_query(drop_query)
             except:
@@ -42,7 +51,23 @@ class NativeAppTeardownProcessor(NativeAppManager, NativeAppCommandProcessor):
 
             cc.message(f"Dropped {object_type} {object_name} successfully.")
 
-    def drop_application(self, auto_yes: bool):
+    def _application_objects_to_str(
+        self, application_objects: ApplicationOwnedObject
+    ) -> str:
+        """
+        Returns a list in an "(Object Type) Object Name" format. Database-level and schema-level object names are fully qualified:
+        (COMPUTE_POOL) POOL_NAME
+        (DATABASE) DB_NAME
+        (SCHEMA) DB_NAME.PUBLIC
+        ...
+        """
+        return "\n".join(
+            [f"({obj['type']}) {obj['name']}" for obj in application_objects]
+        )
+
+    def drop_application(
+        self, auto_yes: bool, interactive: bool = False, cascade: Optional[bool] = None
+    ):
         """
         Attempts to drop the application object if all validations and user prompts allow so.
         """
@@ -89,9 +114,45 @@ class NativeAppTeardownProcessor(NativeAppManager, NativeAppCommandProcessor):
                     cc.message(f"Did not drop application object {self.app_name}.")
                     return  # The user desires to keep the app, therefore exit gracefully
 
-        # 4. All validations have passed, drop object
+        # 4. Check for application objects owned by the application
+        application_objects = self.get_objects_owned_by_application()
+        if len(application_objects) > 0:
+            application_objects_str = self._application_objects_to_str(
+                application_objects
+            )
+            if cascade is True:
+                cc.message(
+                    f"The following objects are owned by application {self.app_name} and will be dropped:\n{application_objects_str}"
+                )
+            elif cascade is False:
+                cc.message(
+                    f"The following objects are owned by application {self.app_name}:\n{application_objects_str}"
+                )
+            elif interactive:
+                if interactive:
+                    api_integration = typer.prompt(
+                        f"The following objects are owned by application {self.app_name}:\n{application_objects_str}\n\nWould you like to drop these objects in addition to the application? [y/n/ABORT]"
+                    )
+                    if api_integration in ["y", "yes", "Y", "Yes", "YES"]:
+                        cascade = True
+                    elif api_integration in ["n", "no", "N", "No", "NO"]:
+                        cascade = False
+                    else:
+                        raise typer.Abort()
+            else:
+                cc.message(
+                    f"The following application objects are owned by application {self.app_name}:\n{application_objects_str}\n\nRe-run teardown again with --cascade or --no-cascade to specify whether these objects should be dropped along with the application."
+                )
+                raise typer.Abort()
+        elif cascade is None:
+            cascade = False
+
+        # 5. All validations have passed, drop object
         self.drop_generic_object(
-            object_type="application", object_name=self.app_name, role=self.app_role
+            object_type="application",
+            object_name=self.app_name,
+            role=self.app_role,
+            cascade=cascade,
         )
         return  # The application object was successfully dropped, therefore exit gracefully
 
@@ -176,10 +237,19 @@ class NativeAppTeardownProcessor(NativeAppManager, NativeAppCommandProcessor):
         )
         return  # The application package was successfully dropped, therefore exit gracefully
 
-    def process(self, force_drop: bool = False, *args, **kwargs):
+    def process(
+        self,
+        interactive: bool,
+        force_drop: bool = False,
+        cascade: Optional[bool] = None,
+        *args,
+        **kwargs,
+    ):
 
         # Drop the application object
-        self.drop_application(auto_yes=force_drop)
+        self.drop_application(
+            auto_yes=force_drop, interactive=interactive, cascade=cascade
+        )
 
         # Drop the application package
         self.drop_package(auto_yes=force_drop)

snowflake/cli/plugins/nativeapp/utils.py

@@ -1,4 +1,6 @@
-from os import PathLike
+from __future__ import annotations
+
+import os
 from pathlib import Path
 from sys import stdin, stdout
 from typing import List, Optional, Union
@@ -43,7 +45,7 @@ def get_first_paragraph_from_markdown_file(file_path: Path) -> Optional[str]:
         return paragraph_text
 
 
-def shallow_git_clone(url: Union[str, PathLike], to_path: Union[str, PathLike]):
+def shallow_git_clone(url: Union[str, os.PathLike], to_path: Union[str, os.PathLike]):
     """
     Performs a shallow clone of the repository at the provided url to the path specified
 
@@ -77,7 +79,6 @@ def verify_no_directories(paths_to_sync: List[Path]):
             )
 
 
-def verify_exists(paths_to_sync: List[Path]):
-    for path in paths_to_sync:
-        if not path.exists():
-            raise ClickException(f"The following path does not exist: {path}")
+def verify_exists(path: Path):
+    if not path.exists():
+        raise ClickException(f"The following path does not exist: {path}")

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

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 from typing import Optional
 
@@ -16,7 +18,6 @@ from snowflake.cli.plugins.nativeapp.policy import (
     DenyAlwaysPolicy,
 )
 from snowflake.cli.plugins.nativeapp.run_processor import NativeAppRunProcessor
-from snowflake.cli.plugins.nativeapp.utils import is_tty_interactive
 from snowflake.cli.plugins.nativeapp.version.version_processor import (
     NativeAppVersionCreateProcessor,
     NativeAppVersionDropProcessor,
@@ -49,7 +50,7 @@ def create(
         help="When enabled, the Snowflake CLI skips checking if your project has any untracked or stages files in git. Default: unset.",
         is_flag=True,
     ),
-    interactive: Optional[bool] = InteractiveOption,
+    interactive: bool = InteractiveOption,
     force: Optional[bool] = ForceOption,
     **options,
 ) -> CommandResult:
@@ -62,7 +63,7 @@ def create(
     is_interactive = False
     if force:
         policy = AllowAlwaysPolicy()
-    elif interactive or is_tty_interactive():
+    elif interactive:
         is_interactive = True
         policy = AskAlwaysPolicy()
     else:
@@ -113,7 +114,7 @@ def drop(
         None,
         help="Version defined in an application package that you want to drop. Defaults to the version specified in the `manifest.yml` file.",
     ),
-    interactive: Optional[bool] = InteractiveOption,
+    interactive: bool = InteractiveOption,
     force: Optional[bool] = ForceOption,
     **options,
 ) -> CommandResult:
@@ -124,7 +125,7 @@ def drop(
     is_interactive = False
     if force:
         policy = AllowAlwaysPolicy()
-    elif interactive or is_tty_interactive():
+    elif interactive:
         is_interactive = True
         policy = AskAlwaysPolicy()
     else:

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

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pathlib import Path
 from textwrap import dedent
 from typing import Dict, List, Optional

snowflake/cli/plugins/notebook/commands.py

@@ -6,6 +6,8 @@ from snowflake.cli.api.commands.snow_typer import SnowTyper
 from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.output.types import MessageResult
 from snowflake.cli.plugins.notebook.manager import NotebookManager
+from snowflake.cli.plugins.notebook.types import NotebookName, NotebookStagePath
+from typing_extensions import Annotated
 
 app = SnowTyper(
     name="notebook",
@@ -15,6 +17,11 @@ app = SnowTyper(
 log = logging.getLogger(__name__)
 
 NOTEBOOK_IDENTIFIER = identifier_argument(sf_object="notebook", example="MY_NOTEBOOK")
+NotebookFile: NotebookStagePath = typer.Option(
+    "--notebook-file",
+    "-f",
+    help="Stage path with notebook file. For example `@stage/path/to/notebook.ipynb`",
+)
 
 
 @app.command(requires_connection=True)
@@ -49,3 +56,17 @@ def open_cmd(
     url = NotebookManager().get_url(notebook_name=identifier)
     typer.launch(url)
     return MessageResult(message=url)
+
+
+@app.command(requires_connection=True)
+def create(
+    identifier: Annotated[NotebookName, NOTEBOOK_IDENTIFIER],
+    notebook_file: Annotated[NotebookStagePath, NotebookFile],
+    **options,
+):
+    """Creates notebook from stage."""
+    notebook_url = NotebookManager().create(
+        notebook_name=identifier,
+        notebook_file=notebook_file,
+    )
+    return MessageResult(message=notebook_url)

snowflake/cli/plugins/notebook/exceptions.py

@@ -0,0 +1,6 @@
+from click.exceptions import ClickException
+
+
+class NotebookStagePathError(ClickException):
+    def __init__(self, path: str):
+        super().__init__(f"Cannot extract notebook file name from {path=}")

snowflake/cli/plugins/notebook/manager.py

@@ -1,14 +1,57 @@
+from pathlib import Path
+from textwrap import dedent
+
+from snowflake.cli.api.cli_global_context import cli_context
+from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.cli.plugins.connection.util import make_snowsight_url
+from snowflake.cli.plugins.notebook.exceptions import NotebookStagePathError
+from snowflake.cli.plugins.notebook.types import NotebookName, NotebookStagePath
 
 
 class NotebookManager(SqlExecutionMixin):
-    def execute(self, notebook_name: str):
+    def execute(self, notebook_name: NotebookName):
         query = f"EXECUTE NOTEBOOK {notebook_name}()"
         return self._execute_query(query=query)
 
-    def get_url(self, notebook_name: str):
+    def get_url(self, notebook_name: NotebookName):
+        fqn = FQN.from_string(notebook_name).using_connection(self._conn)
         return make_snowsight_url(
             self._conn,
-            f"/#/notebooks/{self.qualified_name_for_url(notebook_name)}",
+            f"/#/notebooks/{fqn.url_identifier}",
+        )
+
+    @staticmethod
+    def parse_stage_as_path(notebook_file: NotebookName) -> Path:
+        """Parses notebook file path to pathlib.Path."""
+        if not notebook_file.endswith(".ipynb"):
+            raise NotebookStagePathError(notebook_file)
+        stage_path = Path(notebook_file)
+        if len(stage_path.parts) < 2:
+            raise NotebookStagePathError(notebook_file)
+
+        return stage_path
+
+    def create(
+        self,
+        notebook_name: NotebookName,
+        notebook_file: NotebookStagePath,
+    ) -> str:
+        notebook_fqn = FQN.from_string(notebook_name).using_connection(self._conn)
+        stage_path = self.parse_stage_as_path(notebook_file)
+
+        queries = dedent(
+            f"""
+            CREATE OR REPLACE NOTEBOOK {notebook_fqn.identifier}
+            FROM '{stage_path.parent}'
+            QUERY_WAREHOUSE = '{cli_context.connection.warehouse}'
+            MAIN_FILE = '{stage_path.name}';
+
+            ALTER NOTEBOOK {notebook_fqn.identifier} ADD LIVE VERSION FROM LAST;
+            """
+        )
+        self._execute_queries(queries=queries)
+
+        return make_snowsight_url(
+            self._conn, f"/#/notebooks/{notebook_fqn.url_identifier}"
         )

snowflake/cli/plugins/notebook/types.py

@@ -0,0 +1,2 @@
+NotebookName = str
+NotebookStagePath = str

snowflake/cli/plugins/object/command_aliases.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from typing import List, Optional, Tuple
+
+import typer
+from click import ClickException
+from snowflake.cli.api.commands.snow_typer import SnowTyper
+from snowflake.cli.api.constants import ObjectType
+from snowflake.cli.plugins.object.commands import (
+    ScopeOption,
+    describe,
+    drop,
+    list_,
+    scope_option,  # noqa: F401
+)
+
+
+def add_object_command_aliases(
+    app: SnowTyper,
+    object_type: ObjectType,
+    name_argument: typer.Argument,
+    like_option: Optional[typer.Option],
+    scope_option: Optional[typer.Option],
+    ommit_commands: List[str] = [],
+):
+    if "list" not in ommit_commands:
+        if not like_option:
+            raise ClickException('[like_option] have to be defined for "list" command')
+
+        if not scope_option:
+
+            @app.command("list", requires_connection=True)
+            def list_cmd(like: str = like_option, **options):  # type: ignore
+                list_(
+                    object_type=object_type.value.cli_name,
+                    like=like,
+                    scope=ScopeOption.default,
+                    **options,
+                )
+
+        else:
+
+            @app.command("list", requires_connection=True)
+            def list_cmd(
+                like: str = like_option,  # type: ignore
+                scope: Tuple[str, str] = scope_option,  # type: ignore
+                **options,
+            ):
+                list_(
+                    object_type=object_type.value.cli_name,
+                    like=like,
+                    scope=scope,
+                    **options,
+                )
+
+        list_cmd.__doc__ = f"Lists all available {object_type.value.sf_plural_name}."
+
+    if "drop" not in ommit_commands:
+
+        @app.command("drop", requires_connection=True)
+        def drop_cmd(name: str = name_argument, **options):
+            drop(
+                object_type=object_type.value.cli_name,
+                object_name=name,
+                **options,
+            )
+
+        drop_cmd.__doc__ = f"Drops {object_type.value.sf_name} with given name."
+
+    if "describe" not in ommit_commands:
+
+        @app.command("describe", requires_connection=True)
+        def describe_cmd(name: str = name_argument, **options):
+            describe(
+                object_type=object_type.value.cli_name,
+                object_name=name,
+                **options,
+            )
+
+        describe_cmd.__doc__ = f"Provides description of {object_type.value.sf_name}."