SNOW-2229492 and SNOW-2229493 - cleanup versions in DCM (#2511)

* remove --no-version parameter

* remove dcm add_version command

* remove `--version` flag for `dcm plan` and `dcm deploy` - use given stage or upload local files

* Reverted logic in test_project_deploy_from_stage

* Reverted logic in test_project_drop_version

* Reverted logic in test_project_deploy

* Add support for `snow dcm deploy --alias` and revert drop_version integration test logic

* port `--prune` from non-existing `add-version` to `dcm plan` and `dcm deploy`

* fix the integation test for prune

* SNOW-2229498 rename show versions to show deployments in dcm (#2510)

* review fixes

* rely on existing user-facing errors

Author: sfc-gh-daniszewski

src/snowflake/cli/_plugins/dcm/commands.py

@@ -11,7 +11,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 from typing import List, Optional
 
 import typer
@@ -22,13 +21,13 @@
 from snowflake.cli._plugins.object.command_aliases import add_object_command_aliases
 from snowflake.cli._plugins.object.commands import scope_option
 from snowflake.cli._plugins.object.manager import ObjectManager
+from snowflake.cli.api.artifacts.upload import sync_artifacts_with_stage
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.commands.decorators import with_project_definition
 from snowflake.cli.api.commands.flags import (
     IfExistsOption,
     IfNotExistsOption,
     OverrideableOption,
-    PruneOption,
     entity_argument,
     identifier_argument,
     like_option,
@@ -46,6 +45,7 @@
     QueryJsonValueResult,
     QueryResult,
 )
+from snowflake.cli.api.project.project_paths import ProjectPaths
 
 app = SnowTyperFactory(
     name="dcm",
@@ -54,12 +54,6 @@
 )
 
 dcm_identifier = identifier_argument(sf_object="DCM Project", example="MY_PROJECT")
-version_flag = typer.Option(
-    None,
-    "--version",
-    help="Version of the DCM Project to use. If not specified default version is used. For names containing '$', use single quotes to prevent shell expansion (e.g., 'VERSION$1').",
-    show_default=False,
-)
 variables_flag = variables_option(
     'Variables for the execution context; for example: `-D "<key>=<value>"`.'
 )
@@ -72,6 +66,22 @@
 from_option = OverrideableOption(
     None,
     "--from",
+    mutually_exclusive=["prune"],
+    show_default=False,
+)
+
+prune_option = OverrideableOption(
+    False,
+    "--prune",
+    help="Remove unused artifacts from the stage during sync. Mutually exclusive with --from.",
+    mutually_exclusive=["from_stage"],
+    show_default=False,
+)
+
+alias_option = typer.Option(
+    None,
+    "--alias",
+    help="Alias for the deployment.",
     show_default=False,
 )
 
@@ -91,52 +101,46 @@
 @app.command(requires_connection=True)
 def deploy(
     identifier: FQN = dcm_identifier,
-    version: Optional[str] = version_flag,
     from_stage: Optional[str] = from_option(
-        help="Apply changes defined in given stage instead of using a specific project version."
+        help="Deploy DCM Project deployment from a given stage."
     ),
     variables: Optional[List[str]] = variables_flag,
     configuration: Optional[str] = configuration_flag,
+    alias: Optional[str] = alias_option,
+    prune: bool = prune_option(),
     **options,
 ):
     """
     Applies changes defined in DCM Project to Snowflake.
     """
-    if version and from_stage:
-        raise CliError("--version and --from are mutually exclusive.")
-
     result = DCMProjectManager().execute(
         project_name=identifier,
         configuration=configuration,
-        version=version,
-        from_stage=from_stage,
+        from_stage=from_stage if from_stage else _sync_local_files(prune=prune),
         variables=variables,
+        alias=alias,
     )
     return QueryJsonValueResult(result)
 
 
 @app.command(requires_connection=True)
 def plan(
     identifier: FQN = dcm_identifier,
-    version: Optional[str] = version_flag,
     from_stage: Optional[str] = from_option(
-        help="Plan DCM Project deployment from given stage instead of using a specific version."
+        help="Plan DCM Project deployment from a given stage."
     ),
     variables: Optional[List[str]] = variables_flag,
     configuration: Optional[str] = configuration_flag,
+    prune: bool = prune_option(),
     **options,
 ):
     """
     Plans a DCM Project deployment (validates without executing).
     """
-    if version and from_stage:
-        raise CliError("--version and --from are mutually exclusive.")
-
     result = DCMProjectManager().execute(
         project_name=identifier,
         configuration=configuration,
-        version=version,
-        from_stage=from_stage,
+        from_stage=from_stage if from_stage else _sync_local_files(prune=prune),
         dry_run=True,
         variables=variables,
     )
@@ -147,19 +151,13 @@ def plan(
 @with_project_definition()
 def create(
     entity_id: str = entity_argument("dcm"),
-    no_version: bool = typer.Option(
-        False,
-        "--no-version",
-        help="Do not initialize DCM Project with a new version, only create the snowflake object.",
-    ),
     if_not_exists: bool = IfNotExistsOption(
         help="Do nothing if the project already exists."
     ),
     **options,
 ):
     """
     Creates a DCM Project in Snowflake.
-    By default, the DCM Project is initialized with a new version created from local files.
     """
     cli_context = get_cli_context()
     project: DCMProjectEntityModel = get_entity_for_operation(
@@ -175,76 +173,23 @@ def create(
             return MessageResult(message)
         raise CliError(message)
 
-    if not no_version and om.object_exists(
-        object_type="stage", fqn=FQN.from_stage(project.stage)
-    ):
+    if om.object_exists(object_type="stage", fqn=FQN.from_stage(project.stage)):
         raise CliError(f"Stage '{project.stage}' already exists.")
 
     dpm = DCMProjectManager()
     with cli_console.phase(f"Creating DCM Project '{project.fqn}'"):
-        dpm.create(project=project, initialize_version_from_local_files=not no_version)
-
-    if no_version:
-        return MessageResult(f"DCM Project '{project.fqn}' successfully created.")
-    return MessageResult(
-        f"DCM Project '{project.fqn}' successfully created and initial version is added."
-    )
-
+        dpm.create(project=project)
 
-@app.command(requires_connection=True)
-@with_project_definition()
-def add_version(
-    entity_id: str = entity_argument("dcm"),
-    _from: Optional[str] = from_option(
-        help="Create a new version using given stage instead of uploading local files."
-    ),
-    _alias: Optional[str] = typer.Option(
-        None, "--alias", help="Alias for the version.", show_default=False
-    ),
-    comment: Optional[str] = typer.Option(
-        None, "--comment", help="Version comment.", show_default=False
-    ),
-    prune: bool = PruneOption(default=True),
-    **options,
-):
-    """Uploads local files to Snowflake and cerates a new DCM Project version."""
-    if _from is not None and prune:
-        cli_console.warning(
-            "When `--from` option is used, `--prune` option will be ignored and files from stage will be used as they are."
-        )
-        prune = False
-    cli_context = get_cli_context()
-    project: DCMProjectEntityModel = get_entity_for_operation(
-        cli_context=cli_context,
-        entity_id=entity_id,
-        project_definition=cli_context.project_definition,
-        entity_type="dcm",
-    )
-    om = ObjectManager()
-    if not om.object_exists(object_type="dcm", fqn=project.fqn):
-        raise CliError(
-            f"DCM Project '{project.fqn}' does not exist. Use `dcm create` command first."
-        )
-    DCMProjectManager().add_version(
-        project=project,
-        prune=prune,
-        from_stage=_from,
-        alias=_alias,
-        comment=comment,
-    )
-    alias_str = "" if _alias is None else f"'{_alias}' "
-    return MessageResult(
-        f"New version {alias_str}added to DCM Project '{project.fqn}'."
-    )
+    return MessageResult(f"DCM Project '{project.fqn}' successfully created.")
 
 
 @app.command(requires_connection=True)
-def list_versions(
+def list_deployments(
     identifier: FQN = dcm_identifier,
     **options,
 ):
     """
-    Lists versions of given DCM Project.
+    Lists deployments of given DCM Project.
     """
     pm = DCMProjectManager()
     results = pm.list_versions(project_name=identifier)
@@ -280,3 +225,23 @@ def drop_version(
     return MessageResult(
         f"Version '{version_name}' dropped from DCM Project '{identifier}'."
     )
+
+
+def _sync_local_files(prune: bool = False) -> str:
+    cli_context = get_cli_context()
+    project_entity = get_entity_for_operation(
+        cli_context=cli_context,
+        entity_id=None,
+        project_definition=cli_context.project_definition,
+        entity_type="dcm",
+    )
+
+    with cli_console.phase("Syncing local files to stage"):
+        sync_artifacts_with_stage(
+            project_paths=ProjectPaths(project_root=cli_context.project_root),
+            stage_root=project_entity.stage,
+            artifacts=project_entity.artifacts,
+            prune=prune,
+        )
+
+    return project_entity.stage

src/snowflake/cli/_plugins/dcm/manager.py

@@ -11,37 +11,35 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from textwrap import dedent
-from typing import List, Optional
+
+from typing import List
 
 from snowflake.cli._plugins.dcm.dcm_project_entity_model import DCMProjectEntityModel
 from snowflake.cli._plugins.stage.manager import StageManager
-from snowflake.cli.api.artifacts.upload import sync_artifacts_with_stage
-from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.commands.utils import parse_key_value_variables
-from snowflake.cli.api.console.console import cli_console
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.project.project_paths import ProjectPaths
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.cli.api.stage_path import StagePath
-from snowflake.connector.cursor import SnowflakeCursor
 
 
 class DCMProjectManager(SqlExecutionMixin):
     def execute(
         self,
         project_name: FQN,
+        from_stage: str,
         configuration: str | None = None,
-        version: str | None = None,
-        from_stage: str | None = None,
         variables: List[str] | None = None,
         dry_run: bool = False,
+        alias: str | None = None,
     ):
+
         query = f"EXECUTE DCM PROJECT {project_name.sql_identifier}"
         if dry_run:
             query += " PLAN"
         else:
             query += " DEPLOY"
+            if alias:
+                query += f" AS {alias}"
         if configuration or variables:
             query += f" USING"
         if configuration:
@@ -50,23 +48,13 @@ def execute(
             query += StageManager.parse_execute_variables(
                 parse_key_value_variables(variables)
             ).removeprefix(" using")
-        if version:
-            query += f" WITH VERSION {version}"
-        elif from_stage:
-            stage_path = StagePath.from_stage_str(from_stage)
-            query += f" FROM {stage_path.absolute_path()}"
+        stage_path = StagePath.from_stage_str(from_stage)
+        query += f" FROM {stage_path.absolute_path()}"
         return self.execute_query(query=query)
 
-    def _create_object(self, project_name: FQN) -> SnowflakeCursor:
-        query = dedent(f"CREATE DCM PROJECT {project_name.sql_identifier}")
-        return self.execute_query(query)
-
-    def create(
-        self, project: DCMProjectEntityModel, initialize_version_from_local_files: bool
-    ) -> None:
-        self._create_object(project.fqn)
-        if initialize_version_from_local_files:
-            self.add_version(project=project)
+    def create(self, project: DCMProjectEntityModel) -> None:
+        query = f"CREATE DCM PROJECT {project.fqn.sql_identifier}"
+        self.execute_query(query)
 
     def _create_version(
         self,
@@ -84,38 +72,6 @@ def _create_version(
             query += f" COMMENT = '{comment}'"
         return self.execute_query(query=query)
 
-    def add_version(
-        self,
-        project: DCMProjectEntityModel,
-        prune: bool = False,
-        from_stage: Optional[str] = None,
-        alias: Optional[str] = None,
-        comment: Optional[str] = None,
-    ):
-        """
-        Adds a version to DCM Project. If [from_stage] is not defined,
-        uploads local files to the stage defined in DCM Project definition.
-        """
-
-        if not from_stage:
-            cli_context = get_cli_context()
-            from_stage = project.stage
-            with cli_console.phase("Uploading artifacts"):
-                sync_artifacts_with_stage(
-                    project_paths=ProjectPaths(project_root=cli_context.project_root),
-                    stage_root=from_stage,
-                    artifacts=project.artifacts,
-                    prune=prune,
-                )
-
-        with cli_console.phase(f"Creating DCM Project version from stage {from_stage}"):
-            return self._create_version(
-                project_name=project.fqn,
-                from_stage=from_stage,  # type:ignore
-                alias=alias,
-                comment=comment,
-            )
-
     def list_versions(self, project_name: FQN):
         query = f"SHOW VERSIONS IN DCM PROJECT {project_name.identifier}"
         return self.execute_query(query=query)