Feat!: Expand Functionality of GitHub Action CI/CD Bot (#1499)

* feat!: support sync and desync patterns github cicd bot

* add youtube link

Author: eakmanrq

docs/integrations/github.md

@@ -0,0 +1,3 @@
+from sqlmesh.integrations.github.cicd.config import GithubCICDBotConfig
+
+CICDBotConfig = GithubCICDBotConfig

docs/integrations/github/cicd_bot_desync.png

@@ -32,3 +32,30 @@ class CategorizerConfig(BaseConfig):
     python: AutoCategorizationMode = AutoCategorizationMode.OFF
     sql: AutoCategorizationMode = AutoCategorizationMode.FULL
     seed: AutoCategorizationMode = AutoCategorizationMode.FULL
+
+    @classmethod
+    def all_off(cls) -> CategorizerConfig:
+        return cls(
+            external=AutoCategorizationMode.OFF,
+            python=AutoCategorizationMode.OFF,
+            sql=AutoCategorizationMode.OFF,
+            seed=AutoCategorizationMode.OFF,
+        )
+
+    @classmethod
+    def all_semi(cls) -> CategorizerConfig:
+        return cls(
+            external=AutoCategorizationMode.SEMI,
+            python=AutoCategorizationMode.SEMI,
+            sql=AutoCategorizationMode.SEMI,
+            seed=AutoCategorizationMode.SEMI,
+        )
+
+    @classmethod
+    def all_full(cls) -> CategorizerConfig:
+        return cls(
+            external=AutoCategorizationMode.FULL,
+            python=AutoCategorizationMode.FULL,
+            sql=AutoCategorizationMode.FULL,
+            seed=AutoCategorizationMode.FULL,
+        )

docs/integrations/github/cicd_bot_sync.png

@@ -7,6 +7,7 @@
 from pydantic import Field
 from sqlglot.helper import first
 
+from sqlmesh.cicd.config import CICDBotConfig
 from sqlmesh.core import constants as c
 from sqlmesh.core.config import EnvironmentSuffixTarget
 from sqlmesh.core.config.base import BaseConfig, UpdateStrategy
@@ -80,6 +81,7 @@ class Config(BaseConfig):
         default=EnvironmentSuffixTarget.default
     )
     default_target_environment: str = c.PROD
+    cicd_bot: t.Optional[CICDBotConfig] = None
 
     _FIELD_UPDATE_STRATEGY: t.ClassVar[t.Dict[str, UpdateStrategy]] = {
         "gateways": UpdateStrategy.KEY_UPDATE,

sqlmesh/cicd/config.py

@@ -48,7 +48,12 @@
 
 from sqlmesh.core import constants as c
 from sqlmesh.core.audit import Audit, StandaloneAudit
-from sqlmesh.core.config import Config, load_config_from_paths, load_config_from_yaml
+from sqlmesh.core.config import (
+    CategorizerConfig,
+    Config,
+    load_config_from_paths,
+    load_config_from_yaml,
+)
 from sqlmesh.core.console import Console, get_console
 from sqlmesh.core.context_diff import ContextDiff
 from sqlmesh.core.dialect import (
@@ -96,6 +101,7 @@
     MissingDependencyError,
     PlanError,
     SQLMeshError,
+    UncategorizedPlanError,
 )
 from sqlmesh.utils.jinja import JinjaMacroRegistry
 
@@ -711,6 +717,7 @@ def plan(
         effective_from: t.Optional[TimeLike] = None,
         include_unmodified: t.Optional[bool] = None,
         select_models: t.Optional[t.Collection[str]] = None,
+        categorizer_config: t.Optional[CategorizerConfig] = None,
     ) -> Plan:
         """Interactively create a migration plan.
 
@@ -743,9 +750,11 @@ def plan(
             no_auto_categorization: Indicates whether to disable automatic categorization of model
                 changes (breaking / non-breaking). If not provided, then the corresponding configuration
                 option determines the behavior.
+            categorizer_config: The configuration for the categorizer. Uses the categorizer configuration defined in the
+                project config by default.
             effective_from: The effective date from which to apply forward-only changes on production.
             include_unmodified: Indicates whether to include unmodified models in the target development environment.
-            model_selections: A list of model selection strings to filter the models that should be included into this plan.
+            select_models: A list of model selection strings to filter the models that should be included into this plan.
 
         Returns:
             The populated Plan object.
@@ -809,7 +818,7 @@ def plan(
             forward_only=forward_only,
             environment_ttl=environment_ttl,
             environment_suffix_target=self.config.environment_suffix_target,
-            categorizer_config=self.auto_categorize_changes,
+            categorizer_config=categorizer_config or self.auto_categorize_changes,
             auto_categorization_enabled=not no_auto_categorization,
             effective_from=effective_from,
             include_unmodified=include_unmodified,
@@ -840,7 +849,7 @@ def apply(self, plan: Plan) -> None:
         ):
             return
         if plan.uncategorized:
-            raise PlanError("Can't apply a plan with uncategorized changes.")
+            raise UncategorizedPlanError("Can't apply a plan with uncategorized changes.")
         self.notification_target_manager.notify(
             NotificationEvent.APPLY_START, environment=plan.environment.name
         )

sqlmesh/core/config/categorizer.py

@@ -1,34 +1,20 @@
 from __future__ import annotations
 
 import logging
-import typing as t
 
 import click
 
 from sqlmesh.integrations.github.cicd.controller import (
     GithubCheckConclusion,
     GithubCheckStatus,
     GithubController,
-    MergeMethod,
+    TestFailure,
 )
 from sqlmesh.utils.errors import CICDBotError, PlanError
 
 logger = logging.getLogger(__name__)
 
 
-merge_method_option = click.option(
-    "--merge-method",
-    type=click.Choice(MergeMethod),  # type: ignore
-    help="Enables merging PR after successfully deploying to production using the provided method.",
-)
-
-delete_option = click.option(
-    "--delete",
-    is_flag=True,
-    help="Delete the PR environment after successfully deploying to production",
-)
-
-
 @click.group(no_args_is_help=True)
 @click.option(
     "--token",
@@ -68,13 +54,13 @@ def check_required_approvers(ctx: click.Context) -> None:
 def _run_tests(controller: GithubController) -> bool:
     controller.update_test_check(status=GithubCheckStatus.IN_PROGRESS)
     try:
-        result, failed_output = controller.run_tests()
+        result, output = controller.run_tests()
         controller.update_test_check(
             status=GithubCheckStatus.COMPLETED,
             # Conclusion will be updated with final status based on test results
             conclusion=GithubCheckConclusion.NEUTRAL,
             result=result,
-            failed_output=failed_output,
+            output=output,
         )
         return result.wasSuccessful()
     except Exception:
@@ -95,15 +81,17 @@ def _update_pr_environment(controller: GithubController) -> bool:
     controller.update_pr_environment_check(status=GithubCheckStatus.IN_PROGRESS)
     try:
         controller.update_pr_environment()
-        controller.update_pr_environment_check(
-            status=GithubCheckStatus.COMPLETED, conclusion=GithubCheckConclusion.SUCCESS
+        conclusion = controller.update_pr_environment_check(status=GithubCheckStatus.COMPLETED)
+        return conclusion is not None and conclusion.is_success
+    except Exception as e:
+        conclusion = controller.update_pr_environment_check(
+            status=GithubCheckStatus.COMPLETED, exception=e
         )
-        return True
-    except PlanError:
-        controller.update_pr_environment_check(
-            status=GithubCheckStatus.COMPLETED, conclusion=GithubCheckConclusion.ACTION_REQUIRED
+        return (
+            conclusion is not None
+            and not conclusion.is_failure
+            and not conclusion.is_action_required
         )
-        return False
 
 
 @github.command()
@@ -113,21 +101,43 @@ def update_pr_environment(ctx: click.Context) -> None:
     _update_pr_environment(ctx.obj["github"])
 
 
-def _deploy_production(
-    controller: GithubController,
-    merge_method: t.Optional[MergeMethod],
-    delete_environment_after_deploy: bool = True,
-) -> bool:
+def _gen_prod_plan(controller: GithubController) -> bool:
+    controller.update_prod_plan_preview_check(status=GithubCheckStatus.IN_PROGRESS)
+    try:
+        plan_summary = controller.get_plan_summary(controller.prod_plan)
+        controller.update_prod_plan_preview_check(
+            status=GithubCheckStatus.COMPLETED,
+            conclusion=GithubCheckConclusion.SUCCESS,
+            summary=plan_summary,
+        )
+        return bool(plan_summary)
+    except Exception as e:
+        controller.update_prod_plan_preview_check(
+            status=GithubCheckStatus.COMPLETED,
+            conclusion=GithubCheckConclusion.FAILURE,
+            summary=str(e),
+        )
+        return False
+
+
+@github.command()
+@click.pass_context
+def gen_prod_plan(ctx: click.Context) -> None:
+    """Generates the production plan"""
+    controller = ctx.obj["github"]
+    controller.update_prod_plan_preview_check(status=GithubCheckStatus.IN_PROGRESS)
+    _gen_prod_plan(controller)
+
+
+def _deploy_production(controller: GithubController) -> bool:
     controller.update_prod_environment_check(status=GithubCheckStatus.IN_PROGRESS)
     try:
         controller.deploy_to_prod()
         controller.update_prod_environment_check(
             status=GithubCheckStatus.COMPLETED, conclusion=GithubCheckConclusion.SUCCESS
         )
-        if merge_method:
-            controller.merge_pr(merge_method=merge_method)
-        if delete_environment_after_deploy:
-            controller.delete_pr_environment()
+        controller.try_merge_pr()
+        controller.try_invalidate_pr_environment()
         return True
     except PlanError:
         controller.update_prod_environment_check(
@@ -137,27 +147,22 @@ def _deploy_production(
 
 
 @github.command()
-@merge_method_option
-@delete_option
 @click.pass_context
-def deploy_production(
-    ctx: click.Context, merge_method: t.Optional[MergeMethod], delete: bool
-) -> None:
+def deploy_production(ctx: click.Context) -> None:
     """Deploys the production environment"""
-    _deploy_production(
-        ctx.obj["github"], merge_method=merge_method, delete_environment_after_deploy=delete
-    )
+    _deploy_production(ctx.obj["github"])
 
 
-def _run_all(
-    controller: GithubController,
-    merge_method: t.Optional[MergeMethod],
-    delete: bool,
-    command_namespace: t.Optional[str] = None,
-) -> None:
+def _run_all(controller: GithubController) -> None:
     has_required_approval = False
+    is_auto_deploying_prod = (
+        controller.deploy_command_enabled or controller.do_required_approval_check
+    )
     if controller.is_comment_added:
-        command = controller.get_command_from_comment(command_namespace)
+        if not controller.deploy_command_enabled:
+            # We aren't using commands so we can just return
+            return
+        command = controller.get_command_from_comment()
         if command.is_invalid:
             # Probably a comment unrelated to SQLMesh so we do nothing
             return
@@ -166,41 +171,70 @@ def _run_all(
         else:
             raise CICDBotError(f"Unsupported command: {command}")
     controller.update_pr_environment_check(status=GithubCheckStatus.QUEUED)
-    controller.update_prod_environment_check(status=GithubCheckStatus.QUEUED)
+    controller.update_prod_plan_preview_check(status=GithubCheckStatus.QUEUED)
     controller.update_test_check(status=GithubCheckStatus.QUEUED)
+    if is_auto_deploying_prod:
+        controller.update_prod_environment_check(status=GithubCheckStatus.QUEUED)
     tests_passed = _run_tests(controller)
-    if not has_required_approval and controller.do_required_approval_check:
-        controller.update_required_approval_check(status=GithubCheckStatus.QUEUED)
-        has_required_approval = _check_required_approvers(controller)
-    else:
-        controller.update_required_approval_check(
-            status=GithubCheckStatus.COMPLETED, conclusion=GithubCheckConclusion.SKIPPED
+    if controller.do_required_approval_check:
+        if has_required_approval:
+            controller.update_required_approval_check(
+                status=GithubCheckStatus.COMPLETED, conclusion=GithubCheckConclusion.SKIPPED
+            )
+        else:
+            controller.update_required_approval_check(status=GithubCheckStatus.QUEUED)
+            has_required_approval = _check_required_approvers(controller)
+    if not tests_passed:
+        controller.update_pr_environment_check(
+            status=GithubCheckStatus.COMPLETED,
+            exception=TestFailure(),
         )
-    pr_environment_updated = _update_pr_environment(controller)
-    if tests_passed and has_required_approval and pr_environment_updated:
-        _deploy_production(
-            controller, merge_method=merge_method, delete_environment_after_deploy=delete
+        controller.update_prod_plan_preview_check(
+            status=GithubCheckStatus.COMPLETED,
+            conclusion=GithubCheckConclusion.SKIPPED,
+            summary="Unit Test(s) Failed so skipping creating prod plan",
         )
+        if is_auto_deploying_prod:
+            controller.update_prod_environment_check(
+                status=GithubCheckStatus.COMPLETED,
+                conclusion=GithubCheckConclusion.SKIPPED,
+                skip_reason="Unit Test(s) Failed so skipping deploying to production",
+            )
+        return
+    pr_environment_updated = _update_pr_environment(controller)
+    prod_plan_generated = False
+    if pr_environment_updated:
+        prod_plan_generated = _gen_prod_plan(controller)
     else:
-        controller.update_prod_environment_check(
+        controller.update_prod_plan_preview_check(
             status=GithubCheckStatus.COMPLETED, conclusion=GithubCheckConclusion.SKIPPED
         )
+    if tests_passed and has_required_approval and pr_environment_updated and prod_plan_generated:
+        _deploy_production(controller)
+    elif is_auto_deploying_prod:
+        if not has_required_approval:
+            skip_reason = (
+                "Skipped Deploying to Production because a required approver has not approved"
+            )
+        elif not pr_environment_updated:
+            skip_reason = (
+                "Skipped Deploying to Production because the PR environment was not updated"
+            )
+        elif not prod_plan_generated:
+            skip_reason = (
+                "Skipped Deploying to Production because the production plan could not be generated"
+            )
+        else:
+            skip_reason = "Skipped Deploying to Production for an unknown reason"
+        controller.update_prod_environment_check(
+            status=GithubCheckStatus.COMPLETED,
+            conclusion=GithubCheckConclusion.SKIPPED,
+            skip_reason=skip_reason,
+        )
 
 
 @github.command()
-@merge_method_option
-@delete_option
-@click.option(
-    "--command_namespace",
-    type=str,
-    help="Namespace to use for SQLMesh commands. For example if you provide `#SQLMesh` as a value then commands will be expected in the format of `#SQLMesh/<command>`.",
-)
 @click.pass_context
-def run_all(
-    ctx: click.Context,
-    merge_method: t.Optional[MergeMethod],
-    delete: bool,
-    command_namespace: t.Optional[str],
-) -> None:
+def run_all(ctx: click.Context) -> None:
     """Runs all the commands in the correct order."""
-    return _run_all(ctx.obj["github"], merge_method, delete, command_namespace)
+    return _run_all(ctx.obj["github"])