atlas-init 0.1.0__py3-none-any.whl → 0.1.4__py3-none-any.whl

atlas_init/cli_helper/go.py

@@ -2,8 +2,6 @@ import logging
 import os
 from pathlib import Path
 
-import dotenv
-
 from atlas_init.cli_helper.run import run_command_is_ok
 from atlas_init.settings.config import TestSuite
 from atlas_init.settings.env_vars import AtlasInitSettings
@@ -18,7 +16,12 @@ def run_go_tests(
     settings: AtlasInitSettings,
     groups: list[TestSuite],
 ):
-    test_env = os.environ | dotenv.dotenv_values(settings.env_vars_vs_code)
+    extra_vars = settings.load_env_vars(settings.env_vars_vs_code)
+    logger.info(f"go test env-vars-extra: {sorted(extra_vars)}")
+    test_env = os.environ | extra_vars
+    ci_value = test_env.pop("CI", None)
+    if ci_value:
+        logger.warning(f"pooped CI={ci_value}")
     for group in groups:
         packages = ",".join(f"{package_prefix}/{pkg}" for pkg in group.repo_go_packages.get(repo_alias, []))
         if not packages:

atlas_init/cli_helper/run.py

@@ -13,7 +13,11 @@ StrT = TypeVar("StrT", bound=str)
 
 
 def run_command_is_ok(
-    cmd: list[StrT], env: dict | None, cwd: Path | str, logger: Logger, output: None | IO = None
+    cmd: list[StrT],
+    env: dict | None,
+    cwd: Path | str,
+    logger: Logger,
+    output: IO | None = None,
 ) -> bool:
     env = env or {**os.environ}
     command_str = " ".join(cmd)
@@ -73,13 +77,25 @@ def run_command_exit_on_failure(
         raise typer.Exit(1)
 
 
-def run_command_receive_result(command: str, cwd: Path, logger: Logger, env: dict | None = None) -> str:
+def run_command_receive_result(
+    command: str, cwd: Path, logger: Logger, env: dict | None = None, *, can_fail: bool = False
+) -> str:
     with TemporaryDirectory() as temp_dir:
         result_file = Path(temp_dir) / "file"
         with open(result_file, "w") as file:
             is_ok = run_command_is_ok(command.split(), env=env, cwd=cwd, logger=logger, output=file)
         output_text = result_file.read_text().strip()
     if not is_ok:
+        if can_fail:
+            logger.warning(f"command failed {command}, {output_text}")
+            return f"FAIL: {output_text}"
         logger.critical(f"command failed {command}, {output_text}")
         raise typer.Exit(1)
     return output_text
+
+
+def add_to_clipboard(clipboard_content: str, logger: Logger):
+    if pb_binary := find_binary_on_path("pbcopy", logger, allow_missing=True):
+        subprocess.run(pb_binary, text=True, input=clipboard_content, check=True)
+    else:
+        logger.warning("pbcopy not found on $PATH")

atlas_init/cli_helper/tf_runner.py

@@ -1,6 +1,5 @@
 import logging
 import os
-import subprocess
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
@@ -9,7 +8,7 @@ from model_lib import dump
 from zero_3rdparty.file_utils import copy, iter_paths_and_relative
 
 from atlas_init.cli_helper.run import (
-    find_binary_on_path,
+    add_to_clipboard,
     run_command_is_ok,
     run_command_receive_result,
 )
@@ -19,12 +18,14 @@ from atlas_init.settings.env_vars import AtlasInitSettings
 logger = logging.getLogger(__name__)
 
 
-def get_tf_vars(settings: AtlasInitSettings, active_groups: list[TestSuite]) -> dict[str, Any]:
-    tf_vars = TerraformVars()
+def get_tf_vars(settings: AtlasInitSettings, active_groups: list[TestSuite]) -> dict[str, Any]:  # type: ignore
+    tf_vars = TerraformVars()  # type: ignore
     tf_vars = sum((group.vars for group in active_groups), start=tf_vars)
     return {
         "atlas_public_key": settings.MONGODB_ATLAS_PUBLIC_KEY,
         "atlas_private_key": settings.MONGODB_ATLAS_PRIVATE_KEY,
+        "atlas_base_url": settings.MONGODB_ATLAS_BASE_URL,
+        "is_mongodbgov_cloud": settings.is_mongodbgov_cloud,
         "org_id": settings.MONGODB_ATLAS_ORG_ID,
         "aws_region": settings.AWS_REGION,
         "project_name": settings.project_name,
@@ -41,28 +42,22 @@ class TerraformRunError(Exception):
 
 @dataclass
 class state_copier:  # noqa: N801
-    profile_path: Path
+    state_path: Path
     tf_path: Path
 
-    @property
-    def state_path(self) -> Path:
-        return self.profile_path / "tf_state"
-
     def __enter__(self):
-        if not self.state_path.exists():
-            return
+        self.state_path.mkdir(exist_ok=True, parents=True)
         for state_path, rel_path in iter_paths_and_relative(self.state_path, "terraform.tfstate*", rglob=False):
             copy(state_path, self.tf_path / rel_path)
 
     def __exit__(self, *_):
-        if not self.tf_path.exists():
-            return
+        self.tf_path.mkdir(exist_ok=True, parents=True)
         for state_path, rel_path in iter_paths_and_relative(self.tf_path, "terraform.tfstate*", rglob=False):
             state_path.rename(self.state_path / rel_path)
 
 
 def run_terraform(settings: AtlasInitSettings, command: str, extra_args: list[str]):
-    with state_copier(settings.profile_dir, settings.tf_path):
+    with state_copier(settings.tf_state_path, settings.tf_path):
         _run_terraform(settings, command, extra_args)
 
 
@@ -87,10 +82,7 @@ def _run_terraform(settings: AtlasInitSettings, command: str, extra_args: list[s
     env_generated = settings.env_vars_generated
     if env_generated.exists():
         clipboard_content = "\n".join(f"export {line}" for line in env_generated.read_text().splitlines())
-        pb_binary = find_binary_on_path("pbcopy", logger, allow_missing=True)
-        if not pb_binary:
-            return
-        subprocess.run(pb_binary, text=True, input=clipboard_content, check=True)
+        add_to_clipboard(clipboard_content, logger)
         logger.info("loaded env-vars to clipboard ✅")
 
 
@@ -103,12 +95,11 @@ def dump_tf_vars(settings: AtlasInitSettings, tf_vars: dict[str, Any]):
 
 
 def export_outputs(settings: AtlasInitSettings) -> None:
-    output_path = settings.profile_dir / "tf_outputs.json"
-    with state_copier(settings.profile_dir, settings.tf_path):
+    with state_copier(settings.tf_state_path, settings.tf_path):
         result = run_command_receive_result(
             "terraform output -json",
             settings.tf_path,
             logger,
             env=os.environ | {"TF_DATA_DIR": settings.tf_data_dir},
         )
-    output_path.write_text(result)
+    settings.tf_outputs_path.write_text(result)

atlas_init/cli_root/trigger.py

@@ -0,0 +1,153 @@
+import logging
+
+import requests
+from zero_3rdparty.id_creator import simple_id
+
+from atlas_init.settings.env_vars import init_settings
+from atlas_init.settings.path import dump_dotenv, dump_vscode_dotenv
+from atlas_init.typer_app import app_command
+
+logger = logging.getLogger(__name__)
+
+
+@app_command()
+def trigger_app():
+    settings = init_settings()
+    login_req = {
+        "username": settings.MONGODB_ATLAS_PUBLIC_KEY,
+        "apiKey": settings.MONGODB_ATLAS_PRIVATE_KEY,
+    }
+    response = requests.post(
+        "https://realm-dev.mongodb.com/api/admin/v3.0/auth/providers/mongodb-cloud/login",
+        json=login_req,
+        headers={"Accept": "application/json", "Content-Type": "application/json"},
+        timeout=10,
+    )
+    response.raise_for_status()
+    token_response = response.json()
+    access_token = token_response["access_token"]
+    logger.info(f"token: {access_token}")
+    auth_headers = {"Authorization": f"Bearer {access_token}"}
+    env_vars = settings.load_env_vars_generated()
+    project_id = env_vars["MONGODB_ATLAS_PROJECT_ID"]
+    cluster_name = env_vars["MONGODB_ATLAS_CLUSTER_NAME"]
+    apps = list_apps(auth_headers, project_id)
+    if apps:
+        logger.info(f"got apps: {apps}")
+        app_id = apps[0]["_id"]
+    else:
+        logger.info("no apps found, creating one")
+        app = create_app(auth_headers, project_id, cluster_name)
+        logger.info(f"created app: {app}")
+        app_id = app["_id"]
+    logger.info(f"using app_id: {app_id}")
+    suffix = simple_id(length=5)
+    service = create_service(auth_headers, project_id, cluster_name, app_id, suffix)
+    logger.info(f"new service: {service}")
+    service_id = service["_id"]
+    logger.info(f"using service_id: {service_id}")
+    func_response = create_function(auth_headers, project_id, app_id, suffix)
+    logger.info(f"new function: {func_response}")
+    func_id = func_response["_id"]
+    func_name = func_response["name"]
+    logger.info(f"using func_id: {func_id}")
+    extra_env_vars = {
+        "MONGODB_REALM_APP_ID": app_id,
+        "MONGODB_REALM_SERVICE_ID": service_id,
+        "MONGODB_REALM_FUNCTION_ID": func_id,
+        "MONGODB_REALM_FUNCTION_NAME": func_name,
+        "MONGODB_REALM_BASE_URL": "https://realm-dev.mongodb.com/",
+    }
+    dump_dotenv(settings.env_vars_trigger, extra_env_vars)
+    logger.info(f"done {settings.env_vars_trigger} created with trigger env-vars ✅")
+
+    generated_env_vars = settings.load_env_vars_generated()
+    generated_env_vars.update(extra_env_vars)
+    dump_dotenv(settings.env_vars_generated, generated_env_vars)
+    logger.info(f"done {settings.env_vars_generated} updated  with trigger env-vars ✅")
+
+    dump_vscode_dotenv(settings.env_vars_generated, settings.env_vars_vs_code, **extra_env_vars)
+    logger.info(f"done {settings.env_vars_vs_code} updated with trigger env-vars ✅")
+
+
+def list_apps(auth_headers: dict[str, str], project_id: str) -> list[dict]:
+    existing_apps_response = requests.get(
+        f"https://realm-dev.mongodb.com/api/admin/v3.0/groups/{project_id}/apps",
+        headers=auth_headers,
+        timeout=10,
+    )
+    existing_apps_response.raise_for_status()
+    apps = existing_apps_response.json()
+    assert isinstance(apps, list), f"expected list, got: {apps!r}"
+    return apps
+
+
+def create_app(auth_headers: dict[str, str], project_id: str, cluster_name: str) -> dict:
+    create_app_req = {
+        "name": "atlas-init-app",
+        "location": "US-VA",
+        "deployment_model": "GLOBAL",
+        "environment": "production",
+        "provider_region": "aws-us-east-1",
+        "data_source": {
+            "name": "mongodb-atlas",
+            "type": "mongodb-atlas",
+            "config": {
+                "clusterName": cluster_name,
+                "readPreference": "primary",
+                "wireProtocolEnabled": True,
+            },
+        },
+    }
+    create_app_response = requests.post(
+        f"https://realm-dev.mongodb.com/api/admin/v3.0/groups/{project_id}/apps",
+        json=create_app_req,
+        headers=auth_headers,
+        timeout=10,
+    )
+    create_app_response.raise_for_status()
+    app = create_app_response.json()
+    assert isinstance(app, dict), f"expected dict, got: {app!r}"
+    return app
+
+
+def create_service(auth_headers: dict[str, str], project_id: str, cluster_name: str, app_id: str, suffix: str) -> dict:
+    create_service_req = {
+        "name": f"atlas-init-{suffix}",
+        "type": "mongodb-atlas",
+        "config": {
+            "clusterName": cluster_name,
+            "readPreference": "primary",
+            "wireProtocolEnabled": True,
+        },
+    }
+    create_service_response = requests.post(
+        f"https://realm-dev.mongodb.com/api/admin/v3.0/groups/{project_id}/apps/{app_id}/services",
+        json=create_service_req,
+        headers=auth_headers,
+        timeout=10,
+    )
+    create_service_response.raise_for_status()
+    service = create_service_response.json()
+    assert isinstance(service, dict), f"expected dict, got: {service}"
+    return service
+
+
+def create_function(auth_headers: dict[str, str], project_id: str, app_id: str, suffix: str) -> dict:
+    create_func_req = {
+        "can_evaluate": {},
+        "name": f"testfunc-{suffix}",
+        "private": True,
+        "source": 'exports = function(changeEvent) {console.log("New Document Inserted")};',
+        "run_as_system": True,
+    }
+    create_func_response = requests.post(
+        f"https://realm-dev.mongodb.com/api/admin/v3.0/groups/{project_id}/apps/{app_id}/functions",
+        json=create_func_req,
+        headers=auth_headers,
+        timeout=10,
+    )
+    create_func_response.raise_for_status()
+    func = create_func_response.json()
+    assert isinstance(func, dict), f"expected dict, got: {func}"
+    return func

atlas_init/cli_tf/app.py

@@ -1,10 +1,32 @@
 import logging
+import os
 import sys
+from collections import defaultdict
+from datetime import timedelta
+from pathlib import Path
 
 import typer
+from zero_3rdparty.datetime_utils import utc_now
 from zero_3rdparty.file_utils import clean_dir
 
-from atlas_init.cli_helper.run import run_binary_command_is_ok
+from atlas_init.cli_helper.run import (
+    add_to_clipboard,
+    run_binary_command_is_ok,
+    run_command_exit_on_failure,
+    run_command_receive_result,
+)
+from atlas_init.cli_tf.changelog import convert_to_changelog
+from atlas_init.cli_tf.github_logs import (
+    GH_TOKEN_ENV_NAME,
+    find_test_runs,
+    include_filestems,
+    include_test_jobs,
+)
+from atlas_init.cli_tf.go_test_run import GoTestRun
+from atlas_init.cli_tf.go_test_summary import (
+    create_detailed_summary,
+    create_short_summary,
+)
 from atlas_init.cli_tf.schema import (
     download_admin_api,
     dump_generator_config,
@@ -12,15 +34,24 @@ from atlas_init.cli_tf.schema import (
     update_provider_code_spec,
 )
 from atlas_init.cli_tf.schema_inspection import log_optional_only
+from atlas_init.cli_tf.schema_v2 import (
+    generate_resource_go_resource_schema,
+    parse_schema,
+)
+from atlas_init.cli_tf.schema_v2_api_parsing import add_api_spec_info
+from atlas_init.cli_tf.schema_v2_sdk import generate_model_go, parse_sdk_model
 from atlas_init.repos.path import Repo, current_repo_path
 from atlas_init.settings.env_vars import init_settings
+from atlas_init.settings.interactive import confirm
 
 app = typer.Typer(no_args_is_help=True)
 logger = logging.getLogger(__name__)
 
 
 @app.command()
-def schema():
+def schema(
+    branch: str = typer.Option("main", "-b", "--branch"),
+):
     settings = init_settings()
     schema_out_path = settings.schema_out_path_computed
     schema_out_path.mkdir(exist_ok=True)
@@ -31,10 +62,11 @@ def schema():
     generator_config_path.write_text(generator_config)
     provider_code_spec_path = schema_out_path / "provider-code-spec.json"
     admin_api_path = schema_out_path / "admin_api.yaml"
+
     if admin_api_path.exists():
         logger.warning(f"using existing admin api @ {admin_api_path}")
     else:
-        download_admin_api(admin_api_path)
+        download_admin_api(admin_api_path, branch=branch)
 
     if not run_binary_command_is_ok(
         cwd=schema_out_path,
@@ -56,7 +88,7 @@ def schema():
     if not run_binary_command_is_ok(
         cwd=schema_out_path,
         binary_name="tfplugingen-framework",
-        command=f"generate resources --input ./{provider_code_spec_path.name} --output {go_code_output.name}",
+        command=f"generate all --input ./{provider_code_spec_path.name} --output {go_code_output.name}",
         logger=logger,
     ):
         logger.critical("failed to generate plugin schema")
@@ -71,3 +103,178 @@ def schema():
 def schema_optional_only():
     repo_path = current_repo_path(Repo.TF)
     log_optional_only(repo_path)
+
+
+@app.command()
+def changelog(
+    pr: str = typer.Argument("", help="the PR number, will read the file in .changelog/$pr_input.txt"),
+    delete_input: bool = typer.Option(False, "-d", "--delete-input"),
+):
+    repo_path = current_repo_path(Repo.TF)
+    changelog_input_path = repo_path / f".changelog/{pr}_input.txt"
+    if not changelog_input_path.exists():
+        logger.critical(f"no file @ {changelog_input_path}")
+        raise typer.Abort
+    changes_in = changelog_input_path.read_text()
+    logger.info(f"will generate changelog to {changelog_input_path} based on changes:\n{changes_in}")
+    changes_out = convert_to_changelog(changes_in)
+    changelog_path = repo_path / f".changelog/{pr}.txt"
+    changelog_path.write_text(changes_out)
+    logger.info(f"updated file ✅ \n{changes_in}\n--> TO:\n{changes_out} ")
+    if delete_input:
+        logger.warning(f"deleting input file {changelog_input_path}")
+        changelog_input_path.unlink()
+
+
+@app.command()
+def example_gen(
+    in_path: Path = typer.Argument(..., help="Path to the latest code"),
+    out_path: Path = typer.Argument("", help="Output path (empty will use input path)"),
+):
+    out_path = out_path or in_path  # type: ignore
+    assert in_path.is_dir(), f"path not found: {in_path}"
+    assert out_path.is_dir(), f"path not found: {out_path}"
+    run_command_exit_on_failure("terraform fmt", cwd=in_path, logger=logger)
+    if in_path == out_path:
+        logger.warning(f"will overwrite/change files in {out_path}")
+    else:
+        logger.info(f"will use from {in_path} -> {out_path}")
+    from zero_3rdparty import file_utils
+
+    for path, rel_path in file_utils.iter_paths_and_relative(in_path, "*.tf", "*.sh", "*.py", "*.md", rglob=False):
+        dest_path = out_path / rel_path
+        file_utils.copy(path, dest_path, clean_dest=False)
+
+
+@app.command()
+def ci_tests(
+    test_group_name: str = typer.Option("", "-g"),
+    max_days_ago: int = typer.Option(1, "-d", "--days"),
+    branch: str = typer.Option("master", "-b", "--branch"),
+    workflow_file_stems: str = typer.Option("test-suite,terraform-compatibility-matrix", "-w", "--workflow"),
+    only_last_workflow: bool = typer.Option(False, "-l", "--last"),
+    names: str = typer.Option(
+        "",
+        "-n",
+        "--test-names",
+        help="comma separated list of test names to filter, e.g., TestAccCloudProviderAccessAuthorizationAzure_basic,TestAccBackupSnapshotExportBucket_basicAzure",
+    ),
+    summary_name: str = typer.Option(
+        "",
+        "-s",
+        "--summary",
+        help="the name of the summary directory to store detailed test results",
+    ),
+):  # sourcery skip: use-named-expression
+    names_set: set[str] = set()
+    if names:
+        names_set.update(names.split(","))
+        logger.info(f"filtering tests by names: {names_set}")
+    repo_path = current_repo_path(Repo.TF)
+    token = run_command_receive_result("gh auth token", cwd=repo_path, logger=logger)
+    os.environ[GH_TOKEN_ENV_NAME] = token
+    end_test_date = utc_now()
+    start_test_date = end_test_date - timedelta(days=max_days_ago)
+    job_runs = find_test_runs(
+        start_test_date,
+        include_job=include_test_jobs(test_group_name),
+        branch=branch,
+        include_workflow=include_filestems(set(workflow_file_stems.split(","))),
+    )
+    test_results: dict[str, list[GoTestRun]] = defaultdict(list)
+    workflow_ids = set()
+    for key in sorted(job_runs.keys(), reverse=True):
+        workflow_id, job_id = key
+        workflow_ids.add(workflow_id)
+        if only_last_workflow and len(workflow_ids) > 1:
+            logger.info("only showing last workflow")
+            break
+        runs = job_runs[key]
+        if not runs:
+            logger.warning(f"no go tests for job_id={job_id}")
+            continue
+        for run in runs:
+            test_name = run.name
+            if names_set and test_name not in names_set:
+                continue
+            test_results[test_name].append(run)
+
+    if summary_name:
+        summary = create_detailed_summary(summary_name, end_test_date, start_test_date, test_results, names_set)
+    else:
+        failing_names = [name for name, name_runs in test_results.items() if all(run.is_failure for run in name_runs)]
+        if not failing_names:
+            logger.info("ALL TESTS PASSED! ✅")
+            return
+        summary = create_short_summary(test_results, failing_names)
+    summary_str = "\n".join(summary)
+    add_to_clipboard(summary_str, logger)
+    logger.info(summary_str)
+
+
+@app.command()
+def schema2(
+    resource: str = typer.Argument(
+        "",
+        help="the resource name to generate the schema for. Must exist in the schema. E.g., 'stream_processor'",
+    ),
+    branch: str = typer.Option("main", "-b", "--branch", help="the branch for downloading openapi spec"),
+    admin_api_path: Path = typer.Option(
+        "", "-a", "--admin-api-path", help="the path to store/download the openapi spec"
+    ),
+    config_path: Path = typer.Option("", "-c", "--config", help="the path to the SchemaV2 config"),
+    replace: bool = typer.Option(False, "-r", "--replace", help="replace the existing schema file"),
+    sdk_repo_path_str: str = typer.Option("", "-sdk", "--sdk-repo-path", help="the path to the sdk repo"),
+):
+    repo_path = current_repo_path(Repo.TF)
+    config_path = config_path or repo_path / "schema_v2.yaml"
+    admin_api_path = admin_api_path or repo_path / "admin_api.yaml"
+    if admin_api_path.exists():
+        logger.info(f"using existing admin api @ {admin_api_path}")
+    else:
+        download_admin_api(admin_api_path, branch=branch)
+    schema = parse_schema(config_path)
+    logger.info("adding api spec info to schema")
+    add_api_spec_info(schema, admin_api_path, minimal_refs=True)
+    go_old = repo_path / f"internal/service/{resource.replace('_', '')}/resource_schema.go"
+    if not go_old.exists():
+        if confirm(
+            f"no file found @ {go_old}, ok to create it?",
+            is_interactive=True,
+            default=True,
+        ):
+            go_old.parent.mkdir(exist_ok=True, parents=True)
+        else:
+            logger.critical(f"no file found @ {go_old}")
+            raise typer.Abort
+    if replace:
+        logger.warning(f"replacing existing schema @ {go_old}")
+        go_new = go_old
+    else:
+        go_new = go_old.with_name("resource_schema_gen.go")
+    gen_src = generate_resource_go_resource_schema(schema, resource)
+    go_new.write_text(gen_src)
+    logger.info(f"generated new schema @ {go_new} ✅")
+
+    resource_schema = schema.resources[resource]
+    if conversion_config := resource_schema.conversion:
+        if not confirm(
+            f"resource {resource} has conversion, ok to generate conversion functions?",
+            is_interactive=True,
+            default=True,
+        ):
+            logger.info("skipping conversion functions")
+            return
+        logger.info("generating conversion functions")
+        if not sdk_repo_path_str:
+            logger.critical("must provide sdk repo path when generating conversion functions")
+            raise typer.Abort
+        sdk_repo_path = Path(sdk_repo_path_str)
+        if not sdk_repo_path.exists():
+            logger.critical(f"no sdk repo found @ {sdk_repo_path}")
+            raise typer.Abort
+        for sdk_start_ref in conversion_config.sdk_start_refs:
+            sdk_model = parse_sdk_model(sdk_repo_path, sdk_start_ref.name)
+            go_conversion_src = generate_model_go(schema, resource_schema, sdk_model)
+            go_conversion_path = go_old.with_name("model.go")
+            go_conversion_path.write_text(go_conversion_src)

atlas_init/cli_tf/changelog.py

@@ -0,0 +1,103 @@
+import logging
+import re
+from typing import Annotated, Literal
+
+import typer
+from model_lib import Entity
+from pydantic import BeforeValidator, model_validator
+
+logger = logging.getLogger(__name__)
+
+
+type ChangelogGroup = Literal["rs", "ds", "dsp"]
+CHANGELOG_GROUPS = {"rs", "ds", "dsp"}
+_group_prefixes = {
+    "rs": "resource/",
+    "ds": "data-source/",
+    "dsp": "data-source/",
+}
+_group_suffixes = {
+    "rs": "",
+    "ds": "",
+    "dsp": "s",
+}
+type ChangelogType = Literal["feat", "fix"]
+CHANGELOG_SEPARATOR = "\n\n"
+_types_headers = {"feat": "enhancement", "fix": "bug"}
+_line_regex = re.compile(r"(?P<type>feat|fix)\((?P<groups>[^\]]+)\)\:\s(?P<text>.*)")
+
+
+def as_group_name(resource_name: str, group: ChangelogGroup):
+    prefix = _group_prefixes[group]
+    suffix = _group_suffixes[group]
+    return f"{prefix}{resource_name}{suffix}"
+
+
+def changelog_header(group: ChangelogType) -> str:
+    return f"release-note:{_types_headers[group]}"
+
+
+def split_on_plus(groups: str | list[str]) -> list[str]:
+    return groups.split("+") if isinstance(groups, str) else groups
+
+
+type GroupsValidation = Annotated[str, BeforeValidator(split_on_plus)]
+
+
+class ChangelogPart(Entity):
+    type: ChangelogType
+    groups: str
+    text: str
+    resource_name: str
+
+    @property
+    def parsed_groups(self) -> list[ChangelogGroup]:
+        groups = set(self.groups.split("+"))
+        if invalid_groups := groups - CHANGELOG_GROUPS:
+            raise ValueError(f"found invalid groups {invalid_groups}, only {CHANGELOG_GROUPS} are valid")
+        return sorted(groups)  # type: ignore
+
+    @model_validator(mode="after")
+    def ensure_parsed_groups(self):
+        assert self.parsed_groups
+        return self
+
+    def as_changelog(self) -> str:
+        parts = []
+        for group in self.parsed_groups:
+            header = changelog_header(self.type)
+            name = as_group_name(self.resource_name, group)
+            parts.append(f"```{header}\n{name}: {self.text}\n```")
+        return CHANGELOG_SEPARATOR.join(parts)
+
+    def __str__(self) -> str:
+        return self.as_changelog()
+
+
+def _convert_to_changelog(changes: str) -> str:
+    if not changes.startswith("rs="):
+        err = "missing rs=YOUR_RESOURCE_NAME e.g., mongodbatlas_federated_settings_org_config"
+        raise ValueError(err)
+    header, *change_lines = changes.splitlines()
+    rs = header.removeprefix("rs=").strip()
+    changelog = []
+    for change in change_lines:
+        if changelog_part := as_changelog_parts(rs, change):
+            changelog.append(changelog_part)
+    logger.info(f"found a total of {len(changelog)} changes")
+    return CHANGELOG_SEPARATOR.join(str(part) for part in changelog)
+
+
+def as_changelog_parts(resource_name: str, line_raw: str) -> ChangelogPart | None:
+    if match := _line_regex.search(line_raw):
+        return ChangelogPart(**match.groupdict(), resource_name=resource_name)  # type: ignore
+    logger.warning(f"unable to parse line: {line_raw}")
+    return None
+
+
+def convert_to_changelog(changes: str) -> str:
+    try:
+        return _convert_to_changelog(changes)
+    except ValueError as e:
+        logger.critical(str(e))
+        raise typer.Abort from e