snowflake-cli 3.0.2__py3-none-any.whl → 3.1.0__py3-none-any.whl

snowflake/cli/_plugins/nativeapp/commands.py

@@ -22,7 +22,6 @@ from textwrap import dedent
 from typing import Generator, Iterable, List, Optional, cast
 
 import typer
-from click.exceptions import ClickException
 from snowflake.cli._plugins.nativeapp.common_flags import (
     ForceOption,
     InteractiveOption,
@@ -32,19 +31,9 @@ from snowflake.cli._plugins.nativeapp.entities.application import ApplicationEnt
 from snowflake.cli._plugins.nativeapp.entities.application_package import (
     ApplicationPackageEntityModel,
 )
-from snowflake.cli._plugins.nativeapp.manager import NativeAppManager
-from snowflake.cli._plugins.nativeapp.policy import (
-    AllowAlwaysPolicy,
-    AskAlwaysPolicy,
-    DenyAlwaysPolicy,
-)
-from snowflake.cli._plugins.nativeapp.run_processor import NativeAppRunProcessor
-from snowflake.cli._plugins.nativeapp.teardown_processor import (
-    NativeAppTeardownProcessor,
-)
-from snowflake.cli._plugins.nativeapp.v2_conversions.v2_to_v1_decorator import (
+from snowflake.cli._plugins.nativeapp.v2_conversions.compat import (
     find_entity,
-    nativeapp_definition_v2_to_v1,
+    force_project_definition_v2,
 )
 from snowflake.cli._plugins.nativeapp.version.commands import app as versions_app
 from snowflake.cli._plugins.stage.diff import (
@@ -67,8 +56,6 @@ from snowflake.cli.api.output.types import (
     ObjectResult,
     StreamResult,
 )
-from snowflake.cli.api.project.project_verification import assert_project_type
-from snowflake.cli.api.project.schemas.project_definition import ProjectDefinitionV1
 from typing_extensions import Annotated
 
 app = SnowTyperFactory(
@@ -80,57 +67,52 @@ app.add_typer(versions_app)
 log = logging.getLogger(__name__)
 
 
-@app.command("init", hidden=True)
-def app_init(**options):
-    """
-    *** Deprecated. Use snow init instead ***
-
-    Initializes a Snowflake Native App project.
-    """
-
-    raise ClickException("This command has been removed. Use `snow init` instead.")
-
-
 @app.command("bundle")
 @with_project_definition()
-@nativeapp_definition_v2_to_v1()
+@force_project_definition_v2()
 def app_bundle(
     **options,
 ) -> CommandResult:
     """
     Prepares a local folder with configured app artifacts.
     """
-
-    assert_project_type("native_app")
-
     cli_context = get_cli_context()
-    manager = NativeAppManager(
-        project_definition=cli_context.project_definition.native_app,
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
         project_root=cli_context.project_root,
     )
-    manager.build_bundle()
-    return MessageResult(f"Bundle generated at {manager.deploy_root}")
+    package_id = options["package_entity_id"]
+    package = cli_context.project_definition.entities[package_id]
+    ws.perform_action(
+        package_id,
+        EntityActions.BUNDLE,
+    )
+    return MessageResult(f"Bundle generated at {ws.project_root / package.deploy_root}")
 
 
 @app.command("diff", requires_connection=True, hidden=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1()
+@force_project_definition_v2()
 def app_diff(
     **options,
-) -> CommandResult:
+) -> CommandResult | None:
     """
     Performs a diff between the app's source stage and the local deploy root.
     """
-    assert_project_type("native_app")
-
     cli_context = get_cli_context()
-    manager = NativeAppManager(
-        project_definition=cli_context.project_definition.native_app,
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
         project_root=cli_context.project_root,
     )
-    bundle_map = manager.build_bundle()
+    package_id = options["package_entity_id"]
+    package = cli_context.project_definition.entities[package_id]
+    bundle_map = ws.perform_action(
+        package_id,
+        EntityActions.BUNDLE,
+    )
+    stage_fqn = f"{package.fqn.name}.{package.stage}"
     diff: DiffResult = compute_stage_diff(
-        local_root=Path(manager.deploy_root), stage_fqn=manager.stage_fqn
+        local_root=Path(package.deploy_root), stage_fqn=stage_fqn
     )
     if cli_context.output_format == OutputFormat.JSON:
         return ObjectResult(diff.to_dict())
@@ -141,7 +123,7 @@ def app_diff(
 
 @app.command("run", requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1(app_required=True)
+@force_project_definition_v2(app_required=True)
 def app_run(
     version: Optional[str] = typer.Option(
         None,
@@ -170,42 +152,35 @@ def app_run(
     Creates an application package in your Snowflake account, uploads code files to its stage,
     then creates or upgrades an application object from the application package.
     """
-
-    assert_project_type("native_app")
-
-    is_interactive = False
-    if force:
-        policy = AllowAlwaysPolicy()
-    elif interactive:
-        is_interactive = True
-        policy = AskAlwaysPolicy()
-    else:
-        policy = DenyAlwaysPolicy()
-
     cli_context = get_cli_context()
-    processor = NativeAppRunProcessor(
-        project_definition=cli_context.project_definition.native_app,
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
         project_root=cli_context.project_root,
     )
-    bundle_map = processor.build_bundle()
-    processor.process(
-        bundle_map=bundle_map,
-        policy=policy,
+    app_id = options["app_entity_id"]
+    app_model = cli_context.project_definition.entities[app_id]
+    ws.perform_action(
+        app_id,
+        EntityActions.DEPLOY,
+        validate=validate,
         version=version,
         patch=patch,
         from_release_directive=from_release_directive,
-        is_interactive=is_interactive,
-        validate=validate,
+        prune=True,
+        recursive=True,
+        paths=[],
+        interactive=interactive,
+        force=force,
     )
+    app = ws.get_entity(app_id)
     return MessageResult(
-        f"Your application object ({processor.app_name}) is now available:\n"
-        + processor.get_snowsight_url()
+        f"Your application object ({app_model.fqn.name}) is now available:\n{app.get_snowsight_url()}"
     )
 
 
 @app.command("open", requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1(app_required=True)
+@force_project_definition_v2(app_required=True)
 def app_open(
     **options,
 ) -> CommandResult:
@@ -213,16 +188,15 @@ def app_open(
     Opens the Snowflake Native App inside of your browser,
     once it has been installed in your account.
     """
-
-    assert_project_type("native_app")
-
     cli_context = get_cli_context()
-    manager = NativeAppManager(
-        project_definition=cli_context.project_definition.native_app,
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
         project_root=cli_context.project_root,
     )
-    if manager.get_existing_app_info():
-        typer.launch(manager.get_snowsight_url())
+    app_id = options["app_entity_id"]
+    app = ws.get_entity(app_id)
+    if app.get_existing_app_info():
+        typer.launch(app.get_snowsight_url())
         return MessageResult(f"Snowflake Native App opened in browser.")
     else:
         return MessageResult(
@@ -232,9 +206,7 @@ def app_open(
 
 @app.command("teardown", requires_connection=True)
 @with_project_definition()
-# This command doesn't use @nativeapp_definition_v2_to_v1 because it needs to
-# be aware of PDFv2 definitions that have multiple apps created from the same package,
-# which all need to be torn down.
+@force_project_definition_v2(single_app_and_package=False)
 def app_teardown(
     force: Optional[bool] = ForceOption,
     cascade: Optional[bool] = typer.Option(
@@ -243,7 +215,7 @@ def app_teardown(
         show_default=False,
     ),
     interactive: bool = InteractiveOption,
-    # Same as the param auto-added by @nativeapp_definition_v2_to_v1
+    # Same as the param auto-added by @force_project_definition_v2 if single_app_and_package were true
     package_entity_id: Optional[str] = typer.Option(
         default="",
         help="The ID of the package entity on which to operate when definition_version is 2 or higher.",
@@ -255,58 +227,49 @@ def app_teardown(
     """
     cli_context = get_cli_context()
     project = cli_context.project_definition
-    if isinstance(project, ProjectDefinitionV1):
-        # Old behaviour, not multi-app aware so we can use the old processor
-        processor = NativeAppTeardownProcessor(
-            project_definition=cli_context.project_definition.native_app,
-            project_root=cli_context.project_root,
-        )
-        processor.process(interactive, force, cascade)
-    else:
-        # New behaviour, multi-app aware so teardown all the apps created from the package
-
-        # Determine the package entity to drop, there must be one
-        app_package_entity = find_entity(
-            project,
-            ApplicationPackageEntityModel,
-            package_entity_id,
-            disambiguation_option="--package-entity-id",
-            required=True,
-        )
-        assert app_package_entity is not None  # satisfy mypy
 
-        # Same implementation as `snow ws drop`
-        ws = WorkspaceManager(
-            project_definition=cli_context.project_definition,
-            project_root=cli_context.project_root,
-        )
-        for app_entity in project.get_entities_by_type(
-            ApplicationEntityModel.get_type()
-        ).values():
-            # Drop each app
-            if app_entity.from_.target == app_package_entity.entity_id:
-                ws.perform_action(
-                    app_entity.entity_id,
-                    EntityActions.DROP,
-                    force_drop=force,
-                    interactive=interactive,
-                    cascade=cascade,
-                )
-        # Then drop the package
-        ws.perform_action(
-            app_package_entity.entity_id,
-            EntityActions.DROP,
-            force_drop=force,
-            interactive=interactive,
-            cascade=cascade,
-        )
+    # Determine the package entity to drop, there must be one
+    app_package_entity = find_entity(
+        project,
+        ApplicationPackageEntityModel,
+        package_entity_id,
+        disambiguation_option="--package-entity-id",
+        required=True,
+    )
+    assert app_package_entity is not None  # satisfy mypy
+
+    # Same implementation as `snow ws drop`
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
+        project_root=cli_context.project_root,
+    )
+    for app_entity in project.get_entities_by_type(
+        ApplicationEntityModel.get_type()
+    ).values():
+        # Drop each app
+        if app_entity.from_.target == app_package_entity.entity_id:
+            ws.perform_action(
+                app_entity.entity_id,
+                EntityActions.DROP,
+                force_drop=force,
+                interactive=interactive,
+                cascade=cascade,
+            )
+    # Then drop the package
+    ws.perform_action(
+        app_package_entity.entity_id,
+        EntityActions.DROP,
+        force_drop=force,
+        interactive=interactive,
+        cascade=cascade,
+    )
 
     return MessageResult(f"Teardown is now complete.")
 
 
 @app.command("deploy", requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1()
+@force_project_definition_v2()
 def app_deploy(
     prune: Optional[bool] = typer.Option(
         default=None,
@@ -338,16 +301,6 @@ def app_deploy(
     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, as in `snow app deploy`, is a shorthand for `snow app deploy --prune --recursive`.
     """
-
-    assert_project_type("native_app")
-
-    if force:
-        policy = AllowAlwaysPolicy()
-    elif interactive:
-        policy = AskAlwaysPolicy()
-    else:
-        policy = DenyAlwaysPolicy()
-
     has_paths = paths is not None and len(paths) > 0
     if prune is None and recursive is None and not has_paths:
         prune = True
@@ -357,24 +310,24 @@ def app_deploy(
             prune = False
         if recursive is None:
             recursive = False
-
     if has_paths and prune:
         raise IncompatibleParametersError(["paths", "--prune"])
 
     cli_context = get_cli_context()
-    manager = NativeAppManager(
-        project_definition=cli_context.project_definition.native_app,
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
         project_root=cli_context.project_root,
     )
-
-    bundle_map = manager.build_bundle()
-    manager.deploy(
-        bundle_map=bundle_map,
+    package_id = options["package_entity_id"]
+    ws.perform_action(
+        package_id,
+        EntityActions.DEPLOY,
         prune=prune,
         recursive=recursive,
-        local_paths_to_sync=paths,
+        paths=paths,
         validate=validate,
-        policy=policy,
+        interactive=interactive,
+        force=force,
     )
 
     return MessageResult(
@@ -384,25 +337,29 @@ def app_deploy(
 
 @app.command("validate", requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1()
+@force_project_definition_v2()
 def app_validate(
     **options,
 ):
     """
     Validates a deployed Snowflake Native App's setup script.
     """
-
-    assert_project_type("native_app")
-
     cli_context = get_cli_context()
-    manager = NativeAppManager(
-        project_definition=cli_context.project_definition.native_app,
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
         project_root=cli_context.project_root,
     )
+    package_id = options["package_entity_id"]
+    package = ws.get_entity(package_id)
     if cli_context.output_format == OutputFormat.JSON:
-        return ObjectResult(manager.get_validation_result(use_scratch_stage=True))
+        return ObjectResult(package.get_validation_result(use_scratch_stage=True))
 
-    manager.validate(use_scratch_stage=True)
+    ws.perform_action(
+        package_id,
+        EntityActions.VALIDATE,
+        interactive=False,
+        force=True,
+    )
     return MessageResult("Snowflake Native App validation succeeded.")
 
 
@@ -419,7 +376,7 @@ DEFAULT_EVENT_FOLLOW_LAST = 20
 
 @app.command("events", requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1(app_required=True)
+@force_project_definition_v2(app_required=True)
 def app_events(
     since: str = typer.Option(
         default="",
@@ -499,48 +456,40 @@ def app_events(
         if first >= 0:
             raise IncompatibleParametersError(["--follow", "--first"])
 
-    assert_project_type("native_app")
+    cli_context = get_cli_context()
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
+        project_root=cli_context.project_root,
+    )
+    app_id = options["app_entity_id"]
 
     record_type_names = [r.name for r in record_types]
-    manager = NativeAppManager(
-        project_definition=get_cli_context().project_definition.native_app,
-        project_root=get_cli_context().project_root,
+
+    if follow and last == -1 and not since:
+        # If we don't have a value for --last or --since, assume a value
+        # for --last so we at least print something before starting the stream
+        last = DEFAULT_EVENT_FOLLOW_LAST
+    stream: Iterable[CommandResult] = (
+        EventResult(event)
+        for event in ws.perform_action(
+            app_id,
+            EntityActions.EVENTS,
+            since=since,
+            until=until,
+            record_types=record_type_names,
+            scopes=scopes,
+            consumer_org=consumer_org,
+            consumer_account=consumer_account,
+            consumer_app_hash=consumer_app_hash,
+            first=first,
+            last=last,
+            follow=follow,
+            interval_seconds=follow_interval,
+        )
     )
     if follow:
-        if last == -1 and not since:
-            # If we don't have a value for --last or --since, assume a value
-            # for --last so we at least print something before starting the stream
-            last = DEFAULT_EVENT_FOLLOW_LAST
-        stream: Iterable[CommandResult] = (
-            EventResult(event)
-            for event in manager.stream_events(
-                since=since,
-                last=last,
-                interval_seconds=follow_interval,
-                record_types=record_type_names,
-                scopes=scopes,
-                consumer_org=consumer_org,
-                consumer_account=consumer_account,
-                consumer_app_hash=consumer_app_hash,
-            )
-        )
         # Append a newline at the end to make the CLI output clean when we hit Ctrl-C
         stream = itertools.chain(stream, [MessageResult("")])
-    else:
-        stream = (
-            EventResult(event)
-            for event in manager.get_events(
-                since=since,
-                until=until,
-                record_types=record_type_names,
-                scopes=scopes,
-                first=first,
-                last=last,
-                consumer_org=consumer_org,
-                consumer_account=consumer_account,
-                consumer_app_hash=consumer_app_hash,
-            )
-        )
 
     # Cast the stream to a Generator since that's what StreamResult wants
     return StreamResult(cast(Generator[CommandResult, None, None], stream))