snowflake-cli-labs 2.8.0rc0__py3-none-any.whl → 2.8.1__py3-none-any.whl

snowflake/cli/__about__.py

@@ -14,4 +14,4 @@
 
 from __future__ import annotations
 
-VERSION = "2.8.0rc0"
+VERSION = "2.8.1"

snowflake/cli/api/commands/flags.py

@@ -28,6 +28,7 @@ from snowflake.cli.api.cli_global_context import cli_context_manager
 from snowflake.cli.api.commands.typer_pre_execute import register_pre_execute_command
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.exceptions import MissingConfiguration
+from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.project.definition_manager import DefinitionManager
 from snowflake.cli.api.rendering.jinja import CONTEXT_KEY
@@ -350,13 +351,23 @@ EnableDiagOption = typer.Option(
     rich_help_panel=_CONNECTION_SECTION,
 )
 
+# Set default via callback to avoid including tempdir path in generated docs (snow --docs).
+# Use constant instead of None, as None is removed from telemetry data.
+_DIAG_LOG_DEFAULT_VALUE = "<temporary_directory>"
+
+
+def _diag_log_path_callback(path: str):
+    if path == _DIAG_LOG_DEFAULT_VALUE:
+        path = tempfile.gettempdir()
+    cli_context_manager.connection_context.set_diag_log_path(Path(path))
+    return path
+
+
 DiagLogPathOption: Path = typer.Option(
     tempfile.gettempdir(),
     "--diag-log-path",
     help="Diagnostic report path",
-    callback=_callback(
-        lambda: cli_context_manager.connection_context.set_diag_log_path
-    ),
+    callback=_diag_log_path_callback,
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
     exists=True,
@@ -514,11 +525,15 @@ def experimental_option(
     )
 
 
-def identifier_argument(sf_object: str, example: str) -> typer.Argument:
+def identifier_argument(
+    sf_object: str, example: str, callback: Callable | None = None
+) -> typer.Argument:
     return typer.Argument(
         ...,
         help=f"Identifier of the {sf_object}. For example: {example}",
         show_default=False,
+        click_type=IdentifierType(),
+        callback=callback,
     )
 
 
@@ -638,3 +653,10 @@ def parse_key_value_variables(variables: Optional[List[str]]) -> List[Variable]:
         key, value = p.split("=", 1)
         result.append(Variable(key.strip(), value.strip()))
     return result
+
+
+class IdentifierType(click.ParamType):
+    name = "TEXT"
+
+    def convert(self, value, param, ctx):
+        return FQN.from_string(value)

snowflake/cli/api/identifiers.py

@@ -35,10 +35,17 @@ class FQN:
     fqn = FQN.from_string("my_name").set_database("db").set_schema("foo")
     """
 
-    def __init__(self, database: str | None, schema: str | None, name: str):
+    def __init__(
+        self,
+        database: str | None,
+        schema: str | None,
+        name: str,
+        signature: str | None = None,
+    ):
         self._database = database
         self._schema = schema
         self._name = name
+        self.signature = signature
 
     @property
     def database(self) -> str | None:
@@ -72,6 +79,8 @@ class FQN:
 
     @property
     def sql_identifier(self) -> str:
+        if self.signature:
+            return f"IDENTIFIER('{self.identifier}'){self.signature}"
         return f"IDENTIFIER('{self.identifier}')"
 
     def __str__(self):
@@ -98,9 +107,13 @@ class FQN:
         else:
             database = None
             schema = result.group("first_qualifier")
-        if signature := result.group("signature"):
-            unqualified_name = unqualified_name + signature
-        return cls(name=unqualified_name, schema=schema, database=database)
+
+        signature = None
+        if result.group("signature"):
+            signature = result.group("signature")
+        return cls(
+            name=unqualified_name, schema=schema, database=database, signature=signature
+        )
 
     @classmethod
     def from_stage(cls, stage: str) -> "FQN":

snowflake/cli/api/project/errors.py

@@ -29,10 +29,25 @@ class SchemaValidationError(ClickException):
     def __init__(self, error: ValidationError):
         errors = error.errors()
         message = f"During evaluation of {error.title} in project definition following errors were encountered:\n"
+
+        def calculate_location(e):
+            if e["loc"] is None:
+                return None
+
+            # show numbers as list indexes and strings as dictionary keys. Example: key1[0].key2
+            result = "".join(
+                f"[{item}]" if isinstance(item, int) else f".{item}"
+                for item in e["loc"]
+            )
+
+            # remove leading dot from the string if any:
+            return result[1:] if result.startswith(".") else result
+
         message += "\n".join(
             [
                 self.message_templates.get(e["type"], self.generic_message).format(
-                    **e, location=".".join(e["loc"]) if e["loc"] is not None else None
+                    **e,
+                    location=calculate_location(e),
                 )
                 for e in errors
             ]

snowflake/cli/api/sql_execution.py

@@ -147,11 +147,11 @@ class SqlExecutionMixin:
                 self.use(object_type=ObjectType.WAREHOUSE, name=prev_wh)
 
     def create_password_secret(
-        self, name: str, username: str, password: str
+        self, name: FQN, username: str, password: str
     ) -> SnowflakeCursor:
         return self._execute_query(
             f"""
-            create secret {name}
+            create secret {name.sql_identifier}
             type = password
             username = '{username}'
             password = '{password}'
@@ -159,11 +159,11 @@ class SqlExecutionMixin:
         )
 
     def create_api_integration(
-        self, name: str, api_provider: str, allowed_prefix: str, secret: Optional[str]
+        self, name: FQN, api_provider: str, allowed_prefix: str, secret: Optional[str]
     ) -> SnowflakeCursor:
         return self._execute_query(
             f"""
-            create api integration {name}
+            create api integration {name.sql_identifier}
             api_provider = {api_provider}
             api_allowed_prefixes = ('{allowed_prefix}')
             allowed_authentication_secrets = ({secret if secret else ''})

snowflake/cli/plugins/git/commands.py

@@ -18,7 +18,7 @@ import itertools
 import logging
 from os import path
 from pathlib import Path
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 import typer
 from click import ClickException
@@ -41,6 +41,7 @@ from snowflake.cli.plugins.object.command_aliases import (
 )
 from snowflake.cli.plugins.object.manager import ObjectManager
 from snowflake.cli.plugins.stage.manager import OnErrorType
+from snowflake.connector import DictCursor
 
 app = SnowTyperFactory(
     name="git",
@@ -82,10 +83,12 @@ add_object_command_aliases(
     scope_option=scope_option(help_example="`list --in database my_db`"),
 )
 
+from snowflake.cli.api.identifiers import FQN
 
-def _assure_repository_does_not_exist(om: ObjectManager, repository_name: str) -> None:
+
+def _assure_repository_does_not_exist(om: ObjectManager, repository_name: FQN) -> None:
     if om.object_exists(
-        object_type=ObjectType.GIT_REPOSITORY.value.cli_name, name=repository_name
+        object_type=ObjectType.GIT_REPOSITORY.value.cli_name, fqn=repository_name
     ):
         raise ClickException(f"Repository '{repository_name}' already exists")
 
@@ -95,9 +98,27 @@ def _validate_origin_url(url: str) -> None:
         raise ClickException("Url address should start with 'https'")
 
 
+def _unique_new_object_name(
+    om: ObjectManager, object_type: ObjectType, proposed_fqn: FQN
+) -> str:
+    existing_objects: List[Dict] = om.show(
+        object_type=object_type.value.cli_name,
+        like=f"{proposed_fqn.name}%",
+        cursor_class=DictCursor,
+    ).fetchall()
+    existing_names = set(o["name"].upper() for o in existing_objects)
+
+    result = proposed_fqn.name
+    i = 1
+    while result.upper() in existing_names:
+        result = proposed_fqn.name + str(i)
+        i += 1
+    return result
+
+
 @app.command("setup", requires_connection=True)
 def setup(
-    repository_name: str = RepoNameArgument,
+    repository_name: FQN = RepoNameArgument,
     **options,
 ) -> CommandResult:
     """
@@ -123,12 +144,29 @@ def setup(
     should_create_secret = False
     secret_name = None
     if secret_needed:
-        secret_name = f"{repository_name}_secret"
-        secret_name = typer.prompt(
-            "Secret identifier (will be created if not exists)", default=secret_name
+        default_secret_name = (
+            FQN.from_string(f"{repository_name.name}_secret")
+            .set_schema(repository_name.schema)
+            .set_database(repository_name.database)
+        )
+        default_secret_name.set_name(
+            _unique_new_object_name(
+                om, object_type=ObjectType.SECRET, proposed_fqn=default_secret_name
+            ),
+        )
+        secret_name = FQN.from_string(
+            typer.prompt(
+                "Secret identifier (will be created if not exists)",
+                default=default_secret_name.name,
+            )
         )
+        if not secret_name.database:
+            secret_name.set_database(repository_name.database)
+        if not secret_name.schema:
+            secret_name.set_schema(repository_name.schema)
+
         if om.object_exists(
-            object_type=ObjectType.SECRET.value.cli_name, name=secret_name
+            object_type=ObjectType.SECRET.value.cli_name, fqn=secret_name
         ):
             cli_console.step(f"Using existing secret '{secret_name}'")
         else:
@@ -137,10 +175,17 @@ def setup(
             secret_username = typer.prompt("username")
             secret_password = typer.prompt("password/token", hide_input=True)
 
-    api_integration = f"{repository_name}_api_integration"
-    api_integration = typer.prompt(
-        "API integration identifier (will be created if not exists)",
-        default=api_integration,
+    # API integration is an account-level object
+    api_integration = FQN.from_string(f"{repository_name.name}_api_integration")
+    api_integration.set_name(
+        typer.prompt(
+            "API integration identifier (will be created if not exists)",
+            default=_unique_new_object_name(
+                om,
+                object_type=ObjectType.INTEGRATION,
+                proposed_fqn=api_integration,
+            ),
+        )
     )
 
     if should_create_secret:
@@ -150,7 +195,7 @@ def setup(
         cli_console.step(f"Secret '{secret_name}' successfully created.")
 
     if not om.object_exists(
-        object_type=ObjectType.INTEGRATION.value.cli_name, name=api_integration
+        object_type=ObjectType.INTEGRATION.value.cli_name, fqn=api_integration
     ):
         manager.create_api_integration(
             name=api_integration,
@@ -177,7 +222,7 @@ def setup(
     requires_connection=True,
 )
 def list_branches(
-    repository_name: str = RepoNameArgument,
+    repository_name: FQN = RepoNameArgument,
     like=like_option(
         help_example='`list-branches --like "%_test"` lists all branches that end with "_test"'
     ),
@@ -186,7 +231,9 @@ def list_branches(
     """
     List all branches in the repository.
     """
-    return QueryResult(GitManager().show_branches(repo_name=repository_name, like=like))
+    return QueryResult(
+        GitManager().show_branches(repo_name=repository_name.identifier, like=like)
+    )
 
 
 @app.command(
@@ -194,7 +241,7 @@ def list_branches(
     requires_connection=True,
 )
 def list_tags(
-    repository_name: str = RepoNameArgument,
+    repository_name: FQN = RepoNameArgument,
     like=like_option(
         help_example='`list-tags --like "v2.0%"` lists all tags that start with "v2.0"'
     ),
@@ -203,7 +250,9 @@ def list_tags(
     """
     List all tags in the repository.
     """
-    return QueryResult(GitManager().show_tags(repo_name=repository_name, like=like))
+    return QueryResult(
+        GitManager().show_tags(repo_name=repository_name.identifier, like=like)
+    )
 
 
 @app.command(
@@ -228,13 +277,13 @@ def list_files(
     requires_connection=True,
 )
 def fetch(
-    repository_name: str = RepoNameArgument,
+    repository_name: FQN = RepoNameArgument,
     **options,
 ) -> CommandResult:
     """
     Fetch changes from origin to Snowflake repository.
     """
-    return QueryResult(GitManager().fetch(repo_name=repository_name))
+    return QueryResult(GitManager().fetch(fqn=repository_name))
 
 
 @app.command(

snowflake/cli/plugins/git/manager.py

@@ -18,6 +18,7 @@ from pathlib import Path
 from textwrap import dedent
 from typing import List
 
+from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.plugins.stage.manager import (
     USER_STAGE_PREFIX,
     StageManager,
@@ -40,17 +41,25 @@ class GitStagePathParts(StagePathParts):
 
     @property
     def path(self) -> str:
-        return (
-            f"{self.stage_name}{self.directory}"
-            if self.stage_name.endswith("/")
-            else f"{self.stage_name}/{self.directory}"
-        )
+        return f"{self.stage_name.rstrip('/')}/{self.directory}"
 
-    def add_stage_prefix(self, file_path: str) -> str:
+    @classmethod
+    def get_directory(cls, stage_path: str) -> str:
+        return "/".join(Path(stage_path).parts[3:])
+
+    @property
+    def full_path(self) -> str:
+        return f"{self.stage.rstrip('/')}/{self.directory}"
+
+    def replace_stage_prefix(self, file_path: str) -> str:
         stage = Path(self.stage).parts[0]
         file_path_without_prefix = Path(file_path).parts[1:]
         return f"{stage}/{'/'.join(file_path_without_prefix)}"
 
+    def add_stage_prefix(self, file_path: str) -> str:
+        stage = self.stage.rstrip("/")
+        return f"{stage}/{file_path.lstrip('/')}"
+
     def get_directory_from_file_path(self, file_path: str) -> List[str]:
         stage_path_length = len(Path(self.directory).parts)
         return list(Path(file_path).parts[3 + stage_path_length : -1])
@@ -63,15 +72,15 @@ class GitManager(StageManager):
     def show_tags(self, repo_name: str, like: str) -> SnowflakeCursor:
         return self._execute_query(f"show git tags like '{like}' in {repo_name}")
 
-    def fetch(self, repo_name: str) -> SnowflakeCursor:
-        return self._execute_query(f"alter git repository {repo_name} fetch")
+    def fetch(self, fqn: FQN) -> SnowflakeCursor:
+        return self._execute_query(f"alter git repository {fqn} fetch")
 
     def create(
-        self, repo_name: str, api_integration: str, url: str, secret: str
+        self, repo_name: FQN, api_integration: str, url: str, secret: str
     ) -> SnowflakeCursor:
         query = dedent(
             f"""
-            create git repository {repo_name}
+            create git repository {repo_name.sql_identifier}
             api_integration = {api_integration}
             origin = '{url}'
             """

snowflake/cli/plugins/init/commands.py

@@ -68,7 +68,8 @@ TemplateOption = typer.Option(
     show_default=False,
 )
 SourceOption = typer.Option(
-    default=DEFAULT_SOURCE,
+    DEFAULT_SOURCE,
+    "--template-source",
     help=f"local path to template directory or URL to git repository with templates.",
 )
 VariablesOption = variables_option(
@@ -132,13 +133,13 @@ def _fetch_remote_template(
     return template_root
 
 
-def _read_template_metadata(template_root: SecurePath) -> Template:
+def _read_template_metadata(template_root: SecurePath, args_error_msg: str) -> Template:
     """Parse template.yml file."""
     template_metadata_path = template_root / TEMPLATE_METADATA_FILE_NAME
     log.debug("Reading template metadata from %s", template_metadata_path.path)
     if not template_metadata_path.exists():
         raise InvalidTemplate(
-            f"Template does not have {TEMPLATE_METADATA_FILE_NAME} file."
+            f"File {TEMPLATE_METADATA_FILE_NAME} not found. {args_error_msg}"
         )
     with template_metadata_path.open(read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB) as fd:
         yaml_contents = yaml.safe_load(fd) or {}
@@ -203,6 +204,7 @@ def init(
     is_remote = any(
         template_source.startswith(prefix) for prefix in ["git@", "http://", "https://"]  # type: ignore
     )
+    args_error_msg = f"Check whether {TemplateOption.param_decls[0]} and {SourceOption.param_decls[0]} arguments are correct."
 
     # copy/download template into tmpdir, so it is going to be removed in case command ends with an error
     with SecurePath.temporary_directory() as tmpdir:
@@ -217,7 +219,9 @@ def init(
                 destination=tmpdir,
             )
 
-        template_metadata = _read_template_metadata(template_root)
+        template_metadata = _read_template_metadata(
+            template_root, args_error_msg=args_error_msg
+        )
         if template_metadata.minimum_cli_version:
             _validate_cli_version(template_metadata.minimum_cli_version)
 

snowflake/cli/plugins/nativeapp/manager.py

@@ -45,6 +45,7 @@ from snowflake.cli.api.project.util import (
 from snowflake.cli.api.rendering.sql_templates import (
     get_sql_cli_jinja_env,
 )
+from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
 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 (
@@ -577,7 +578,10 @@ class NativeAppManager(SqlExecutionMixin):
             )
 
     def _expand_script_templates(
-        self, env: jinja2.Environment, jinja_context: dict[str, Any], scripts: List[str]
+        self,
+        env: jinja2.Environment,
+        jinja_context: dict[str, Any],
+        scripts: List[str],
     ) -> List[str]:
         """
         Input:
@@ -589,20 +593,22 @@ class NativeAppManager(SqlExecutionMixin):
         Size of the return list is the same as the size of the input scripts list.
         """
         scripts_contents = []
-        for relpath in scripts:
+        for script in scripts:
+            full_path = SecurePath(self.project_root) / script
             try:
-                template = env.get_template(relpath)
+                template_content = full_path.read_text(file_size_limit_mb=UNLIMITED)
+                template = env.from_string(template_content)
                 result = template.render(**jinja_context)
                 scripts_contents.append(result)
 
-            except jinja2.TemplateNotFound as e:
-                raise MissingScriptError(e.name) from e
+            except FileNotFoundError as e:
+                raise MissingScriptError(script) from e
 
             except jinja2.TemplateSyntaxError as e:
-                raise InvalidScriptError(e.name, e, e.lineno) from e
+                raise InvalidScriptError(script, e, e.lineno) from e
 
             except jinja2.UndefinedError as e:
-                raise InvalidScriptError(relpath, e) from e
+                raise InvalidScriptError(script, e) from e
 
         return scripts_contents
 
@@ -618,7 +624,7 @@ class NativeAppManager(SqlExecutionMixin):
             )
 
         env = jinja2.Environment(
-            loader=jinja2.loaders.FileSystemLoader(self.project_root),
+            loader=jinja2.BaseLoader(),
             keep_trailing_newline=True,
             undefined=jinja2.StrictUndefined,
         )
@@ -668,19 +674,17 @@ class NativeAppManager(SqlExecutionMixin):
         if not post_deploy_hooks:
             return
 
-        with cc.phase(f"Executing {deployed_object_type} post-deploy actions"):
+        with cc.phase(f"Executing {deployed_object_type} post_deploy actions"):
             sql_scripts_paths = []
             for hook in post_deploy_hooks:
                 if hook.sql_script:
                     sql_scripts_paths.append(hook.sql_script)
                 else:
                     raise ValueError(
-                        f"Unsupported {deployed_object_type} post-deploy hook type: {hook}"
+                        f"Unsupported {deployed_object_type} post_deploy hook type: {hook}"
                     )
 
-            env = get_sql_cli_jinja_env(
-                loader=jinja2.loaders.FileSystemLoader(self.project_root)
-            )
+            env = get_sql_cli_jinja_env()
             scripts_content_list = self._expand_script_templates(
                 env, cli_context.template_context, sql_scripts_paths
             )

snowflake/cli/plugins/notebook/commands.py

@@ -17,9 +17,10 @@ import logging
 import typer
 from snowflake.cli.api.commands.flags import identifier_argument
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.identifiers import FQN
 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 snowflake.cli.plugins.notebook.types import NotebookStagePath
 from typing_extensions import Annotated
 
 app = SnowTyperFactory(
@@ -38,7 +39,7 @@ NotebookFile: NotebookStagePath = typer.Option(
 
 @app.command(requires_connection=True)
 def execute(
-    identifier: str = NOTEBOOK_IDENTIFIER,
+    identifier: FQN = NOTEBOOK_IDENTIFIER,
     **options,
 ):
     """
@@ -51,7 +52,7 @@ def execute(
 
 @app.command(requires_connection=True)
 def get_url(
-    identifier: str = NOTEBOOK_IDENTIFIER,
+    identifier: FQN = NOTEBOOK_IDENTIFIER,
     **options,
 ):
     """Return a url to a notebook."""
@@ -61,7 +62,7 @@ def get_url(
 
 @app.command(name="open", requires_connection=True)
 def open_cmd(
-    identifier: str = NOTEBOOK_IDENTIFIER,
+    identifier: FQN = NOTEBOOK_IDENTIFIER,
     **options,
 ):
     """Opens a notebook in default browser"""
@@ -72,7 +73,7 @@ def open_cmd(
 
 @app.command(requires_connection=True)
 def create(
-    identifier: Annotated[NotebookName, NOTEBOOK_IDENTIFIER],
+    identifier: Annotated[FQN, NOTEBOOK_IDENTIFIER],
     notebook_file: Annotated[NotebookStagePath, NotebookFile],
     **options,
 ):

snowflake/cli/plugins/notebook/manager.py

@@ -20,23 +20,23 @@ 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
+from snowflake.cli.plugins.notebook.types import NotebookStagePath
 
 
 class NotebookManager(SqlExecutionMixin):
-    def execute(self, notebook_name: NotebookName):
-        query = f"EXECUTE NOTEBOOK {notebook_name}()"
+    def execute(self, notebook_name: FQN):
+        query = f"EXECUTE NOTEBOOK {notebook_name.sql_identifier}()"
         return self._execute_query(query=query)
 
-    def get_url(self, notebook_name: NotebookName):
-        fqn = FQN.from_string(notebook_name).using_connection(self._conn)
+    def get_url(self, notebook_name: FQN):
+        fqn = notebook_name.using_connection(self._conn)
         return make_snowsight_url(
             self._conn,
             f"/#/notebooks/{fqn.url_identifier}",
         )
 
     @staticmethod
-    def parse_stage_as_path(notebook_file: NotebookName) -> Path:
+    def parse_stage_as_path(notebook_file: str) -> Path:
         """Parses notebook file path to pathlib.Path."""
         if not notebook_file.endswith(".ipynb"):
             raise NotebookStagePathError(notebook_file)
@@ -48,19 +48,19 @@ class NotebookManager(SqlExecutionMixin):
 
     def create(
         self,
-        notebook_name: NotebookName,
+        notebook_name: FQN,
         notebook_file: NotebookStagePath,
     ) -> str:
-        notebook_fqn = FQN.from_string(notebook_name).using_connection(self._conn)
+        notebook_fqn = 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}
+            CREATE OR REPLACE NOTEBOOK {notebook_fqn.sql_identifier}
             FROM '{stage_path.parent}'
             QUERY_WAREHOUSE = '{cli_context.connection.warehouse}'
             MAIN_FILE = '{stage_path.name}';
-
+            // Cannot use IDENTIFIER(...)
             ALTER NOTEBOOK {notebook_fqn.identifier} ADD LIVE VERSION FROM LAST;
             """
         )

snowflake/cli/plugins/notebook/types.py

@@ -12,5 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-NotebookName = str
 NotebookStagePath = str

snowflake/cli/plugins/object/command_aliases.py

@@ -20,6 +20,7 @@ import typer
 from click import ClickException
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.constants import ObjectType
+from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.plugins.object.commands import (
     ScopeOption,
     describe,
@@ -72,7 +73,7 @@ def add_object_command_aliases(
     if "drop" not in ommit_commands:
 
         @app.command("drop", requires_connection=True)
-        def drop_cmd(name: str = name_argument, **options):
+        def drop_cmd(name: FQN = name_argument, **options):
             return drop(
                 object_type=object_type.value.cli_name,
                 object_name=name,
@@ -84,7 +85,7 @@ def add_object_command_aliases(
     if "describe" not in ommit_commands:
 
         @app.command("describe", requires_connection=True)
-        def describe_cmd(name: str = name_argument, **options):
+        def describe_cmd(name: FQN = name_argument, **options):
             return describe(
                 object_type=object_type.value.cli_name,
                 object_name=name,