Add optional deploy files argument

RELEASE-NOTES.md

@@ -6,6 +6,7 @@
 
 ## New additions
 * `snow sql` command supports now client-side templating of queries.
+* Added the option to specify specific files and directories to sync when running `snow app deploy`.
 
 ## Fixes and improvements
 

src/snowflake/cli/plugins/nativeapp/artifacts.py

@@ -1,14 +1,17 @@
 import os
 from dataclasses import dataclass
 from pathlib import Path
-from typing import List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Tuple, Union
 
-from click import ClickException
+from click.exceptions import ClickException
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
 from snowflake.cli.api.project.schemas.native_app.path_mapping import PathMapping
 from snowflake.cli.api.secure_path import SecurePath
 from yaml import safe_load
 
+# Map from source directories and files in the project directory to their path in the deploy directory. Both paths are absolute.
+ArtifactDeploymentMap = Dict[Path, Path]
+
 
 class DeployRootError(ClickException):
     """
@@ -196,10 +199,11 @@ def resolve_without_follow(path: Path) -> Path:
 
 def build_bundle(
     project_root: Path, deploy_root: Path, artifacts: List[ArtifactMapping]
-):
+) -> ArtifactDeploymentMap:
     """
     Prepares a local folder (deploy_root) with configured app artifacts.
     This folder can then be uploaded to a stage.
+    Returns a mapping of the copied source files, pointing to where they were copied to.
     """
     resolved_root = deploy_root.resolve()
     if resolved_root.exists() and not resolved_root.is_dir():
@@ -217,6 +221,7 @@ def build_bundle(
     if resolved_root.exists():
         delete(resolved_root)
 
+    created_files: ArtifactDeploymentMap = {}
     for artifact in artifacts:
         dest_path = resolve_without_follow(Path(resolved_root, artifact.dest))
         source_paths = get_source_paths(artifact, project_root)
@@ -228,7 +233,9 @@ def build_bundle(
 
             # copy all files as children of the given destination path
             for source_path in source_paths:
-                symlink_or_copy(source_path, dest_path / source_path.name)
+                dest_child_path = dest_path / source_path.name
+                symlink_or_copy(source_path, dest_child_path)
+                created_files[source_path.resolve()] = dest_child_path
         else:
             # ensure we are copying into the deploy root, not replacing it!
             if resolved_root not in dest_path.parents:
@@ -237,9 +244,11 @@ def build_bundle(
             if len(source_paths) == 1:
                 # copy a single file as the given destination path
                 symlink_or_copy(source_paths[0], dest_path)
+                created_files[source_paths[0].resolve()] = dest_path
             else:
                 # refuse to map multiple source files to one destination (undefined behaviour)
                 raise TooManyFilesError(dest_path)
+    return created_files
 
 
 def find_manifest_file(deploy_root: Path) -> Path:
@@ -283,3 +292,33 @@ def find_version_info_in_manifest_file(
             patch_name = version_info[patch_field]
 
     return version_name, patch_name
+
+
+def project_path_to_deploy_path(
+    project_path: Path, created_files: ArtifactDeploymentMap
+) -> Path:
+    """Given a source path, returns the deploy destination path. This function assumes that a bundle was created before calling it."""
+
+    project_path = project_path.resolve()
+
+    if project_path in created_files:
+        return created_files[project_path]
+
+    # Find the first parent directory that exists in created_files
+    common_root = Path(project_path).resolve()
+    while common_root:
+        if common_root in created_files:
+            break
+        elif common_root.parent != common_root:
+            common_root = common_root.parent
+        else:
+            raise FileNotFoundError(project_path)
+
+    # Construct the target deploy path
+    path_to_symlink = created_files[common_root]
+    path_to_target = Path(project_path).relative_to(common_root)
+    result = Path(path_to_symlink, path_to_target)
+
+    if not result.exists():
+        raise FileNotFoundError(result)
+    return result

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

@@ -1,5 +1,6 @@
 import logging
-from typing import Optional
+from pathlib import Path
+from typing import List, Optional
 
 import typer
 from snowflake.cli.api.cli_global_context import cli_context
@@ -229,17 +230,44 @@ def app_teardown(
 @app.command("deploy", requires_connection=True)
 @with_project_definition("native_app")
 def app_deploy(
+    prune: Optional[bool] = typer.Option(
+        default=None,
+        help=f"""Controls whether files that exist only remotely will be deleted from the stage.""",
+    ),
+    recursive: Optional[bool] = typer.Option(
+        None,
+        "--recursive",
+        "-r",
+        help=f"""Controls whether the specified directories should be deployed including all of their contents.""",
+    ),
+    files: Optional[List[Path]] = typer.Argument(
+        default=None,
+        show_default=False,
+        help=f"""Paths of the files, relative to the project root, to be uploaded to a stage. [default: sync all local changes to the stage]""",
+    ),
     **options,
 ) -> CommandResult:
     """
     Creates an application package in your Snowflake account and syncs the local changes to the stage without creating or updating the application.
+    Running this command with no arguments at all is a shorthand for "snow app deploy --prune --recursive".
     """
+    if files is None:
+        files = []
+    if prune is None and recursive is None and len(files) == 0:
+        prune = True
+        recursive = True
+    else:
+        if prune is None:
+            prune = False
+        if recursive is None:
+            recursive = False
+
     manager = NativeAppManager(
         project_definition=cli_context.project_definition,
         project_root=cli_context.project_root,
     )
 
-    manager.build_bundle()
-    manager.deploy()
+    created_files = manager.build_bundle()
+    manager.deploy(prune, recursive, files, created_files)
 
     return MessageResult(f"Deployed successfully.")

src/snowflake/cli/plugins/nativeapp/manager.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 from abc import ABC, abstractmethod
 from functools import cached_property
 from pathlib import Path
@@ -23,8 +24,11 @@
 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,
     build_bundle,
+    project_path_to_deploy_path,
+    resolve_without_follow,
     translate_artifact,
 )
 from snowflake.cli.plugins.nativeapp.constants import (
@@ -45,6 +49,7 @@
 )
 from snowflake.cli.plugins.stage.diff import (
     DiffResult,
+    filter_from_diff,
     stage_diff,
     sync_local_diff_with_stage,
 )
@@ -100,6 +105,28 @@ def ensure_correct_owner(row: dict, role: str, obj_name: str) -> None:
         raise UnexpectedOwnerError(obj_name, role, actual_owner)
 
 
+def _get_files_to_sync(paths_to_sync: List[Path], deploy_root: Path) -> List[str]:
+    """Takes a list of paths (files and directories), returning a list of all files recursively, stripping the path to deploy root."""
+    paths = []
+    for path in paths_to_sync:
+        if path.is_dir():
+            for current_dir, _dirs, files in os.walk(path):
+                for file in files:
+                    deploy_path = Path(current_dir, file).relative_to(deploy_root)
+                    paths.append(str(deploy_path))
+        else:
+            paths.append(str(path.relative_to(deploy_root)))
+    return paths
+
+
+def _verify_no_directories(paths_to_sync):
+    for path in paths_to_sync:
+        if path.is_dir():
+            raise ValueError(
+                f"{path} is a directory. Add the -r flag to deploy directories."
+            )
+
+
 class NativeAppCommandProcessor(ABC):
     @abstractmethod
     def process(self, *args, **kwargs):
@@ -278,13 +305,20 @@ def verify_project_distribution(
             return False
         return True
 
-    def build_bundle(self) -> None:
+    def build_bundle(self) -> ArtifactDeploymentMap:
         """
         Populates the local deploy root from artifact sources.
         """
-        build_bundle(self.project_root, self.deploy_root, self.artifacts)
-
-    def sync_deploy_root_with_stage(self, role: str) -> DiffResult:
+        return build_bundle(self.project_root, self.deploy_root, self.artifacts)
+
+    def sync_deploy_root_with_stage(
+        self,
+        role: str,
+        prune: bool,
+        recursive: bool,
+        paths_to_sync: List[Path] = [],  # relative to project root
+        created_files: Optional[ArtifactDeploymentMap] = None,
+    ) -> DiffResult:
         """
         Ensures that the files on our remote stage match the artifacts we have in
         the local filesystem. Returns the DiffResult used to make changes.
@@ -310,6 +344,23 @@ def sync_deploy_root_with_stage(self, role: str) -> DiffResult:
             % self.deploy_root
         )
         diff: DiffResult = stage_diff(self.deploy_root, self.stage_fqn)
+
+        # If we are syncing specific files/directories, remove everything else from the diff
+        if len(paths_to_sync) > 0:
+            paths_to_sync = [resolve_without_follow(p) for p in paths_to_sync]
+            if not recursive:
+                _verify_no_directories(paths_to_sync)
+            deploy_paths = [
+                project_path_to_deploy_path(p, created_files) for p in paths_to_sync
+            ]
+            paths_to_keep = set(
+                _get_files_to_sync(deploy_paths, self.deploy_root.resolve())
+            )
+            filter_from_diff(diff, paths_to_keep, prune)
+
+        if prune is False:
+            diff.only_on_stage = []
+
         cc.message(str(diff))
 
         # Upload diff-ed files to application package stage
@@ -435,7 +486,13 @@ def _apply_package_scripts(self) -> None:
                 err, role=self.package_role, warehouse=self.package_warehouse
             )
 
-    def deploy(self) -> DiffResult:
+    def deploy(
+        self,
+        prune: bool,
+        recursive: bool,
+        paths_to_sync: List[Path] = [],
+        created_files: Optional[ArtifactDeploymentMap] = None,
+    ) -> DiffResult:
         """app deploy process"""
 
         # 1. Create an empty application package, if none exists
@@ -446,6 +503,8 @@ def deploy(self) -> DiffResult:
             self._apply_package_scripts()
 
             # 3. Upload files from deploy root local folder to the above stage
-            diff = self.sync_deploy_root_with_stage(self.package_role)
+            diff = self.sync_deploy_root_with_stage(
+                self.package_role, prune, recursive, paths_to_sync, created_files
+            )
 
         return diff

src/snowflake/cli/plugins/nativeapp/run_processor.py

@@ -297,5 +297,5 @@ def process(
             )
             return
 
-        diff = self.deploy()
+        diff = self.deploy(prune=True, recursive=True)
         self._create_dev_app(diff)

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

@@ -199,7 +199,9 @@ def process(
             self._apply_package_scripts()
 
             # Upload files from deploy root local folder to the above stage
-            self.sync_deploy_root_with_stage(self.package_role)
+            self.sync_deploy_root_with_stage(
+                self.package_role, prune=True, recursive=True
+            )
 
         # Warn if the version exists in a release directive(s)
         existing_release_directives = (

src/snowflake/cli/plugins/stage/diff.py

@@ -3,9 +3,12 @@
 import re
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Set
 
-from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
+from snowflake.cli.api.console import cli_console as cc
+from snowflake.cli.api.exceptions import (
+    SnowflakeSQLExecutionError,
+)
 from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
 from snowflake.connector.cursor import SnowflakeCursor
 
@@ -149,12 +152,33 @@ def build_md5_map(list_stage_cursor: SnowflakeCursor) -> Dict[str, str]:
     Returns a mapping of relative stage paths to their md5sums.
     """
     return {
-        strip_stage_name(name): md5
-        for (name, size, md5, modified) in list_stage_cursor.fetchall()
+        strip_stage_name(file["name"]): file["md5"]
+        for file in list_stage_cursor.fetchall()
     }
 
 
-def stage_diff(local_path: Path, stage_fqn: str) -> DiffResult:
+def filter_from_diff(
+    diff: DiffResult, paths_to_keep: Set[str], prune: bool
+) -> DiffResult:
+    """Modifies the given diff, keeping only the provided paths. If prune is false, remote-only paths will be empty."""
+    diff.different = [i for i in diff.different if i in paths_to_keep]
+    diff.only_local = [i for i in diff.only_local if i in paths_to_keep]
+    if prune:
+        diff.only_on_stage = [i for i in diff.only_on_stage if i in paths_to_keep]
+    else:
+        files_not_removed = [i for i in diff.only_on_stage if i in paths_to_keep]
+        if len(files_not_removed) > 0:
+            cc.warning(
+                f"The following files exist only on the stage:\n{files_not_removed}\nUse the --prune flag to delete them from the stage."
+            )
+        diff.only_on_stage = []
+    return diff
+
+
+def stage_diff(
+    local_path: Path,
+    stage_fqn: str,
+) -> DiffResult:
     """
     Diffs the files in a stage with a local folder.
     """