atlas-init 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

atlas_init/tf/.terraform.lock.hcl

@@ -2,25 +2,25 @@
 # Manual edits may be lost in future updates.
 
 provider "registry.terraform.io/hashicorp/aws" {
-  version     = "5.98.0"
+  version     = "5.100.0"
   constraints = "~> 5.0"
   hashes = [
-    "h1:neMFK/kP1KT6cTGID+Tkkt8L7PsN9XqwrPDGXVw3WVY=",
-    "zh:23377bd90204b6203b904f48f53edcae3294eb072d8fc18a4531c0cde531a3a1",
-    "zh:2e55a6ea14cc43b08cf82d43063e96c5c2f58ee953c2628523d0ee918fe3b609",
-    "zh:4885a817c16fdaaeddc5031edc9594c1f300db0e5b23be7cd76a473e7dcc7b4f",
-    "zh:6ca7177ad4e5c9d93dee4be1ac0792b37107df04657fddfe0c976f36abdd18b5",
-    "zh:78bf8eb0a67bae5dede09666676c7a38c9fb8d1b80a90ba06cf36ae268257d6f",
-    "zh:874b5a99457a3f88e2915df8773120846b63d820868a8f43082193f3dc84adcb",
-    "zh:95e1e4cf587cde4537ac9dfee9e94270652c812ab31fce3a431778c053abf354",
+    "h1:Ijt7pOlB7Tr7maGQIqtsLFbl7pSMIj06TVdkoSBcYOw=",
+    "zh:054b8dd49f0549c9a7cc27d159e45327b7b65cf404da5e5a20da154b90b8a644",
+    "zh:0b97bf8d5e03d15d83cc40b0530a1f84b459354939ba6f135a0086c20ebbe6b2",
+    "zh:1589a2266af699cbd5d80737a0fe02e54ec9cf2ca54e7e00ac51c7359056f274",
+    "zh:6330766f1d85f01ae6ea90d1b214b8b74cc8c1badc4696b165b36ddd4cc15f7b",
+    "zh:7c8c2e30d8e55291b86fcb64bdf6c25489d538688545eb48fd74ad622e5d3862",
+    "zh:99b1003bd9bd32ee323544da897148f46a527f622dc3971af63ea3e251596342",
     "zh:9b12af85486a96aedd8d7984b0ff811a4b42e3d88dad1a3fb4c0b580d04fa425",
-    "zh:a75145b58b241d64570803e6565c72467cd664633df32678755b51871f553e50",
-    "zh:aa31b13d0b0e8432940d6892a48b6268721fa54a02ed62ee42745186ee32f58d",
-    "zh:ae4565770f76672ce8e96528cbb66afdade1f91383123c079c7fdeafcb3d2877",
-    "zh:b99f042c45bf6aa69dd73f3f6d9cbe0b495b30442c526e0b3810089c059ba724",
-    "zh:bbb38e86d926ef101cefafe8fe090c57f2b1356eac9fc5ec81af310c50375897",
-    "zh:d03c89988ba4a0bd3cfc8659f951183ae7027aa8018a7ca1e53a300944af59cb",
-    "zh:d179ef28843fe663fc63169291a211898199009f0d3f63f0a6f65349e77727ec",
+    "zh:9f8b909d3ec50ade83c8062290378b1ec553edef6a447c56dadc01a99f4eaa93",
+    "zh:aaef921ff9aabaf8b1869a86d692ebd24fbd4e12c21205034bb679b9caf883a2",
+    "zh:ac882313207aba00dd5a76dbd572a0ddc818bb9cbf5c9d61b28fe30efaec951e",
+    "zh:bb64e8aff37becab373a1a0cc1080990785304141af42ed6aa3dd4913b000421",
+    "zh:dfe495f6621df5540d9c92ad40b8067376350b005c637ea6efac5dc15028add4",
+    "zh:f0ddf0eaf052766cfe09dea8200a946519f653c384ab4336e2a4a64fdd6310e9",
+    "zh:f1b7e684f4c7ae1eed272b6de7d2049bb87a0275cb04dbb7cda6636f600699c9",
+    "zh:ff461571e3f233699bf690db319dfe46aec75e58726636a0d97dd9ac6e32fb70",
   ]
 }
 
@@ -103,23 +103,23 @@ provider "registry.terraform.io/hashicorp/random" {
 }
 
 provider "registry.terraform.io/mongodb/mongodbatlas" {
-  version     = "1.33.0"
-  constraints = "1.33.0"
+  version     = "1.37.0"
+  constraints = ">= 1.33.0"
   hashes = [
-    "h1:z8zdSte741iw5ij4wkY8XBAXftY7gEsFjYRMjyk1EX0=",
-    "zh:04e26c9e1dfd11c114c5dbd4e4375bb3a329fbaa2f39f92d01f6bba9d76923ba",
-    "zh:1d175f30a1a2505578c63d7ef76c7c1c846d086ab0e6a1bcebf32d3bfe10a2f6",
-    "zh:1fd08f988587efa41121dbe0cae7298fa8aa739c0038aa2443f8deb53e7367ad",
-    "zh:4c6c337f7a53882e8b5431ba13276bfd1f423becfd4dbbcb0f68443532354455",
-    "zh:4f7028a474d00012280a6069d74584e6eeda2f85be2300040012210f91daa97a",
-    "zh:6ad4d292b60350dae24eb1a6721a7b35f34129ad42a00125ffb7ab6b4565eb15",
-    "zh:6c8f5a14edd77433f559e8440c2b6ee7333c13e5256aa76a17eb585046bef0c1",
-    "zh:8e18a10107beeb9d677e96cc0b25b6f48be9dfbedc62da7bdde7b03b9bfc34b7",
-    "zh:9130c4a1c06ba4587235c479eae182f86b4baadd82a90bd3c69ad54cf2a8c37d",
-    "zh:a1464ff45db030c6b94f9e80e5890061baf4cb3a8595d473d422e2778fc6a5fb",
-    "zh:a20f97e43befeb8a0737cfc2f1a3ea3e483d5928e0baf7dc841bad67d21ac90b",
-    "zh:d3e440568d5f3d2197555ba614d08950cb7fbdf605f3ec2f4b6fc9edff563668",
-    "zh:de11d29abae0ceefd11b6d21575c3335b586d9b27fd5a8ebc8c40a6ce67c01a9",
-    "zh:fea06f8ccd2aec629ca7f24b4cbbd8cba832044d7ee0ee395b3c6e8eab4ed903",
+    "h1:Bn3O8yBFQ25GeP7bqvBEdyLFp/ZZGtxAZI9c1KU/Wek=",
+    "zh:0bb3d85fa4680d804b25341838ae4a5740f59c95b677e818aaeb74957093477c",
+    "zh:14ec370dcdf9c8a92311179089d972a2476c8d17d15ea3cd06c1e772782dcdf6",
+    "zh:16f42470f48c6bf727968cf0ed0fe64dfbdaf49dee626707367073c92006c354",
+    "zh:363bd381dbfed2f3c9a8da2aece2242d8bf2e0a94586422624352c000bcd59d7",
+    "zh:6762334cebaf7a72afdf72dde4edaf3263339e271cbb3946bbaae27f67551b6b",
+    "zh:730006225c2bb49f717610b3f8e1a7413d137b2721de541a254af7856869a203",
+    "zh:9aa5e9bd25788918e6ab7764f37f63d8afe6717c259e17475eed4660b8bed409",
+    "zh:ae0b2ad8660bed54eb1e91da863548bb368701181874d44a989b387a90bc7022",
+    "zh:b2fccfc349dc720239cd348b615790ce44ca7e3ff9f3f89fb30d4a1c7fe58793",
+    "zh:b879a1e1e2cf6585d596da131b150dcf66dd1e937576a161b3afac8bd3ab8e8a",
+    "zh:d23223ac3808f05023d531748e1c718ee0c2277fce8baa0268576220f6cb83a2",
+    "zh:dc6e6776807113723329d730b3cbc4c9d29d0c1c985414d290a63698d8ec06f8",
+    "zh:dff2961bf4b8f8a9d187bfd7d03839a2c2e7c1def13e83bddf82f0cbd794425f",
+    "zh:f5f3fc3b0b80f76c3b535ef33c76064347e96e086b7574f73e1f3931e1ab0b4d",
   ]
 }

atlas_init/tf/modules/aws_s3/provider.tf

@@ -2,7 +2,7 @@ terraform {
   required_providers {
     mongodbatlas = {
       source  = "mongodb/mongodbatlas"
-      version = "1.33"
+      version = ">=1.33"
     }
   }
 

atlas_init/tf/modules/aws_vpc/provider.tf

@@ -2,7 +2,7 @@ terraform {
   required_providers {
     mongodbatlas = {
       source  = "mongodb/mongodbatlas"
-      version = "1.33"
+      version = ">=1.33"
     }
     aws = {
       source = "hashicorp/aws"

atlas_init/tf/modules/cloud_provider/provider.tf

@@ -2,7 +2,7 @@ terraform {
   required_providers {
     mongodbatlas = {
       source  = "mongodb/mongodbatlas"
-      version = "1.33"
+      version = ">=1.33"
     }
     aws = {
       source  = "hashicorp/aws"

atlas_init/tf/modules/cluster/provider.tf

@@ -2,7 +2,7 @@ terraform {
   required_providers {
     mongodbatlas = {
       source  = "mongodb/mongodbatlas"
-      version = "1.33"
+      version = ">=1.33"
     }
   }
 

atlas_init/tf/modules/encryption_at_rest/provider.tf

@@ -2,7 +2,7 @@ terraform {
   required_providers {
     mongodbatlas = {
       source  = "mongodb/mongodbatlas"
-      version = "1.33"
+      version = ">=1.33"
     }
   }
 

atlas_init/tf/modules/federated_vars/federated_vars.tf

@@ -37,7 +37,6 @@ output "env_vars" {
     MONGODB_ATLAS_FEDERATED_GROUP_ID     = var.project_id
     MONGODB_ATLAS_FEDERATED_IDP_ID       = data.mongodbatlas_federated_settings_org_config.current.identity_provider_id # 20 character legacy needed for PATCH on org
     # MONGODB_ATLAS_FEDERATED_IDP_ID = data.mongodbatlas_federated_settings_org_config.current.okta_idp_id # used for org PATCH
-    MONGODB_ATLAS_FEDERATED_SETTINGS_ASSOCIATED_DOMAIN = data.mongodbatlas_federated_settings_org_config.current.domain_allow_list[0]
+    MONGODB_ATLAS_FEDERATED_SETTINGS_ASSOCIATED_DOMAIN = try(data.mongodbatlas_federated_settings_org_config.current.domain_allow_list[0], "no-domain-set-by-atlas-init.com")
   }
-
 }

atlas_init/tf/modules/federated_vars/provider.tf

@@ -2,7 +2,7 @@ terraform {
   required_providers {
     mongodbatlas = {
       source  = "mongodb/mongodbatlas"
-      version = "1.33"
+      version = ">=1.33"
     }
   }
 

atlas_init/tf/modules/project_extra/provider.tf

@@ -2,7 +2,7 @@ terraform {
   required_providers {
     mongodbatlas = {
       source  = "mongodb/mongodbatlas"
-      version = "1.33"
+      version = ">=1.33"
     }
   }
 }

atlas_init/tf/modules/stream_instance/provider.tf

@@ -2,7 +2,7 @@ terraform {
   required_providers {
     mongodbatlas = {
       source  = "mongodb/mongodbatlas"
-      version = "1.33"
+      version = ">=1.33"
     }
   }
 }

atlas_init/tf/modules/vpc_peering/provider.tf

@@ -2,7 +2,7 @@ terraform {
   required_providers {
     mongodbatlas = {
       source  = "mongodb/mongodbatlas"
-      version = "1.33"
+      version = ">=1.33"
     }
   }
 

atlas_init/tf/modules/vpc_privatelink/versions.tf

@@ -6,7 +6,7 @@ terraform {
     }
     mongodbatlas = {
       source  = "mongodb/mongodbatlas"
-      version = "1.33"
+      version = ">=1.33"
     }
   }
 

atlas_init/tf/providers.tf

@@ -2,7 +2,7 @@ terraform {
   required_providers {
     mongodbatlas = {
       source  = "mongodb/mongodbatlas"
-      version = "1.33"
+      version = ">=1.33"
     }
     aws = {
       source  = "hashicorp/aws"

atlas_init/tf_ext/__main__.py

@@ -0,0 +1,3 @@
+from atlas_init.tf_ext.typer_app import typer_main
+
+typer_main()

atlas_init/tf_ext/api_call.py

@@ -0,0 +1,325 @@
+import json
+import logging
+import os
+from collections import defaultdict
+from concurrent.futures import Future, as_completed
+from functools import lru_cache
+from pathlib import Path
+
+import requests
+import typer
+from ask_shell import new_task, print_to_live, run_pool
+from model_lib import dump, parse_model
+from pydantic import BaseModel, Field, model_validator
+from requests.auth import HTTPDigestAuth
+from rich.markdown import Markdown
+from zero_3rdparty.file_utils import ensure_parents_write_text
+from zero_3rdparty.str_utils import ensure_prefix, ensure_suffix, instance_repr
+
+from atlas_init.cli_tf.mock_tf_log import resolve_admin_api_path
+from atlas_init.cli_tf.openapi import OpenapiSchema
+from atlas_init.settings.env_vars import init_settings
+from atlas_init.settings.env_vars_generated import AtlasSettingsWithProject
+from atlas_init.settings.env_vars_modules import (
+    TFModuleCluster,
+    TFModuleFederated_Vars,
+    TFModuleProject_Extra,
+    TFModuleStream_Instance,
+)
+from atlas_init.settings.path import load_dotenv
+from atlas_init.tf_ext.settings import TfExtSettings
+
+logger = logging.getLogger(__name__)
+
+ALLOWED_MISSING_VARS: set[str] = {
+    "alertConfigId",
+    "alertId",
+    "clientId",
+    "cloudProvider",
+    "invoiceId",
+    # "name",
+    "pipelineName",
+    "processId",
+    "username",
+}
+ALLOWED_ERROR_CODES: set[str] = {
+    "CANNOT_USE_CLUSTER_IN_SERVERLESS_INSTANCE_API",
+    "VALIDATION_ERROR",
+    "UNEXPECTED_ERROR",
+    "CANNOT_USE_NON_FLEX_CLUSTER_IN_FLEX_API",
+    "CHECKPOINTS_ONLY_ON_CONTINOUS_BACKUP",
+    "INCORRECT_BACKUP_API_ENDPOINT",
+}
+
+
+# export ATLAS_INIT_TEST_SUITES=clusterm10,s3,federated,project,stream_connection
+def resolve_path_variables() -> dict[str, str]:
+    settings = init_settings()
+    env_vars_full = load_dotenv(settings.env_vars_vs_code)
+    atlas_settings = AtlasSettingsWithProject(**env_vars_full)
+    cluster_settings = TFModuleCluster(**env_vars_full)
+    project_settings = TFModuleProject_Extra(**env_vars_full)
+    stream_settings = TFModuleStream_Instance(**env_vars_full)
+    federated_settings = TFModuleFederated_Vars(**env_vars_full)
+    return {
+        "orgId": atlas_settings.MONGODB_ATLAS_ORG_ID,
+        "cloudProvider": "AWS",
+        "federationSettingsId": federated_settings.MONGODB_ATLAS_FEDERATION_SETTINGS_ID,
+        "clusterName": cluster_settings.MONGODB_ATLAS_CLUSTER_NAME,
+        "name": cluster_settings.MONGODB_ATLAS_CLUSTER_NAME,
+        "groupId": atlas_settings.MONGODB_ATLAS_PROJECT_ID,
+        "teamId": project_settings.MONGODB_ATLAS_TEAM_ID,
+        "tenantName": stream_settings.MONGODB_ATLAS_STREAM_INSTANCE_NAME,
+        "apiUserId": atlas_settings.MONGODB_ATLAS_PROJECT_OWNER_ID,
+        "username": atlas_settings.MONGODB_ATLAS_USER_EMAIL,
+    }
+
+
+class ApiCall(BaseModel):
+    operation_id: str
+    path: str
+    accept_header: str = "application/vnd.atlas.2023-01-01+json"
+    query_args: dict[str, str] = Field(default_factory=dict)
+
+    def __str__(self):
+        return instance_repr(self, ["operation_id", "path"])
+
+    def path_with_variables(self, path_variables: dict[str, str]):
+        return self.path.format(**path_variables)
+
+    @model_validator(mode="after")
+    def check_path_variables(self):
+        self.accept_header = ensure_prefix(self.accept_header, "application/vnd.atlas.")
+        self.accept_header = ensure_suffix(self.accept_header, "+json")
+        return self
+
+
+class UnresolvedPathsError(Exception):
+    def __init__(self, missing_var_paths: dict[str, list[str]]) -> None:
+        self.missing_var_paths = missing_var_paths
+        missing_vars_formatted = "\n".join(f"{var}: {paths}" for var, paths in missing_var_paths.items())
+        super().__init__(f"Failed to resolve path variables:\nMissing vars: {missing_vars_formatted}")
+
+
+class ApiCalls(BaseModel):
+    calls: list[ApiCall] = Field(default_factory=list)
+    ignored_calls: list[ApiCall] = Field(default_factory=list)
+    path_variables: dict[str, str] = Field(default_factory=resolve_path_variables)
+    skip_validation: bool = False
+
+    @model_validator(mode="after")
+    def check_path_variables(self):
+        if self.skip_validation:
+            return self
+        missing_vars_paths: dict[str, list[str]] = defaultdict(list)
+        ok_calls = []
+        for call in self.calls:
+            try:
+                call.path_with_variables(self.path_variables)
+                ok_calls.append(call)
+            except KeyError as e:
+                missing_vars_paths[str(e).strip("'")].append(f"{call.operation_id} {call.path}")
+                self.ignored_calls.append(call)
+                continue
+        for allowed_missing in sorted(ALLOWED_MISSING_VARS):
+            if allowed_missing in missing_vars_paths:
+                logger.info(f"Allowed missing variable {allowed_missing}: {missing_vars_paths[allowed_missing]}")
+                del missing_vars_paths[allowed_missing]
+        if missing_vars_paths:
+            raise UnresolvedPathsError(missing_var_paths=missing_vars_paths)
+        self.calls = ok_calls
+        return self
+
+    def dump_to_dict(self) -> dict:
+        return {
+            "calls": [call.model_dump(exclude_defaults=True, exclude_unset=True) for call in self.calls],
+        }
+
+
+@lru_cache
+def _public_private_key() -> tuple[str, str]:
+    public_key = os.environ.get("MONGODB_ATLAS_PUBLIC_KEY")
+    private_key = os.environ.get("MONGODB_ATLAS_PRIVATE_KEY")
+    if not public_key or not private_key:
+        raise ValueError("MONGODB_ATLAS_PUBLIC_KEY and MONGODB_ATLAS_PRIVATE_KEY must be set in environment variables.")
+    return public_key, private_key
+
+
+class APICallError(Exception):
+    def __init__(self, api_call: ApiCall, json_response: dict, error: requests.exceptions.HTTPError):
+        self.api_call = api_call
+        self.json_response = json_response
+        super().__init__(f"Failed to make API call {api_call}:\njson={json_response}\n{error}")
+
+    @property
+    def error_code(self) -> str:
+        return self.json_response.get("errorCode", "")
+
+
+def call_api(api_call: ApiCall, path_variables: dict[str, str]) -> dict:
+    resolved_path = api_call.path_with_variables(path_variables)
+    response = requests.get(
+        f"https://cloud-dev.mongodb.com/{resolved_path.lstrip('/')}",
+        params=api_call.query_args,
+        headers={"Accept": api_call.accept_header, "Content-Type": "application/json"},
+        auth=HTTPDigestAuth(*_public_private_key()),
+        timeout=30,
+    )
+    try:
+        response_json = response.json()
+    except requests.exceptions.JSONDecodeError as e:
+        logger.error(f"Failed to parse_json {api_call}: {e}")
+        response_json = {}
+    try:
+        response.raise_for_status()
+    except requests.exceptions.HTTPError as e:
+        raise APICallError(api_call, response_json, e) from e
+    return response_json
+
+
+class NoSelfLinkError(Exception):
+    def __init__(self, json_response: dict) -> None:
+        self.json_response = json_response
+        super().__init__("No self link found in response")
+
+
+def parse_href_response(json_response: dict) -> str:
+    for ref in json_response.get("links", []):
+        if ref.get("rel") == "self":
+            return ref.get("href")
+    raise NoSelfLinkError(json_response)
+
+
+def api_config(
+    config_path_str: str = typer.Option("", "-p", "--path", help="Path to the API config file"),
+    query_args_str: str = typer.Option(
+        '{"pageNum": "0", "itemsPerPage": "0"}', "-q", "--query-args", help="Query arguments for the API call"
+    ),
+    verbose: bool = typer.Option(False, "-v", "--verbose", help="Verbose output"),
+):
+    query_args: dict[str, str] = json.loads(query_args_str)
+    if config_path_str == "":
+        with new_task("Find API Calls that use pagination"):
+            config_path = dump_config_path(query_args)
+    else:
+        config_path = Path(config_path_str)
+    assert config_path.exists(), f"Config file {config_path} does not exist."
+    model = parse_model(config_path, t=ApiCalls)
+    total_calls = len(model.calls)
+    assert _public_private_key(), "Public and private keys must be set in environment variables."
+    path_variables = model.path_variables
+    op_id_path_self_qstring: dict[tuple[str, str], str] = {}
+    with run_pool(
+        task_name="make API calls", max_concurrent_submits=10, threads_used_per_submit=1, total=total_calls
+    ) as pool:
+        futures: dict[Future, ApiCall] = {
+            pool.submit(call_api, api_call, path_variables): api_call for api_call in model.calls
+        }
+    for future in as_completed(futures):
+        api_call = futures[future]
+        try:
+            result = future.result()
+        except APICallError as e:
+            if e.error_code in ALLOWED_ERROR_CODES:
+                logger.info(f"Allowed error code {e.error_code} in response for {api_call}")
+                model.ignored_calls.append(api_call)
+                continue
+            raise
+        except Exception as e:
+            logger.error(e)
+            continue
+        try:
+            href = parse_href_response(result)
+            op_id_path_self_qstring[(api_call.operation_id, api_call.path)] = href.split("?")[-1]
+        except NoSelfLinkError as e:
+            logger.error(f"{api_call} did not have a self link in the response:\n{e.json_response}")
+            continue
+        logger.info(f"API call {api_call} completed successfully with self ref:\n{href}")
+        if verbose:
+            logger.info(f"Response for {api_call.query_args} was:\n{dump(result, 'pretty_json')}")
+    query_args_str = "&".join(f"{key}={value}" for key, value in query_args.items())
+    md_report: list[str] = [
+        f"# Pagination Report for query_args='{query_args_str}'",
+        "",
+        "## Checked endpoints",
+        "",
+        "Operation ID | Path | SelfQueryString",
+        "--- | --- | ---",
+        *[
+            f"{operation_id} | {path} | {self_query_string}"
+            for (operation_id, path), self_query_string in op_id_path_self_qstring.items()
+        ],
+        "",
+        "## Ignored endpoints (not checked)",
+        "",
+        "Operation ID | Path",
+        "--- | ---",
+        *[f"{call.operation_id} | {call.path}" for call in model.ignored_calls],
+    ]
+    md_content = "\n".join(md_report)
+    md = Markdown(md_content)
+    print_to_live(md)
+    output_path = TfExtSettings.from_env().pagination_output_path(query_args_str)
+    ensure_parents_write_text(output_path, md_content)
+    logger.info(f"Pagination report saved to {output_path}")
+    return md
+
+
+def api(
+    path: str = typer.Option("-p", "--path", help="Path to the API endpoint"),
+    query_string: str = typer.Option("", "-q", "--query-string", help="Query string for the API call"),
+):
+    assert path, "Path must be provided."
+    accept_header = "application/vnd.atlas.2023-01-01+json"
+    url = f"https://cloud-dev.mongodb.com/{path.lstrip('/')}?{query_string}"
+    logger.info(f"Calling {url}")
+    try:
+        r = requests.get(
+            url,
+            headers={"Accept": accept_header, "Content-Type": "application/json"},
+            auth=HTTPDigestAuth(*_public_private_key()),
+            timeout=30,
+        )
+        print(r.text)
+        r.raise_for_status()
+    except requests.exceptions.HTTPError as e:
+        print(e)
+        print(e.response)
+
+
+def dump_config_path(query_args: dict[str, str]) -> Path:
+    settings = TfExtSettings.from_env()
+    latest_api_spec = resolve_admin_api_path()
+    model = parse_model(latest_api_spec, t=OpenapiSchema)
+    paginated_paths: list[ApiCall] = []
+    path_versions = list(model.path_method_api_versions())
+
+    for (path, method, code), versions in path_versions:
+        if method != "get" or code != "200":
+            continue
+        assert len(versions) == 1, f"{path} {method} {code} has multiple versions: {versions}"
+        get_method = model.get_method(path)
+        if not get_method:
+            continue
+        parameters = get_method.get("parameters", [])
+        for param in parameters:
+            if param_ref := param.get("$ref"):
+                if param_ref.endswith("itemsPerPage"):
+                    version = versions[0].strftime("%Y-%m-%d")
+                    paginated_paths.append(
+                        ApiCall(
+                            path=path,
+                            query_args=query_args,
+                            accept_header=f"application/vnd.atlas.{version}+json",
+                            operation_id=get_method["operationId"],
+                        )
+                    )
+    config_path = settings.api_calls_path
+    calls = ApiCalls(
+        calls=paginated_paths,
+        skip_validation=True,
+    )
+    calls_yaml = dump(calls.dump_to_dict(), "yaml")
+    logger.info(f"Dumped {len(paginated_paths)} API calls to {config_path}")
+    ensure_parents_write_text(config_path, calls_yaml)
+    return config_path

atlas_init/tf_ext/args.py

@@ -0,0 +1,32 @@
+import typer
+
+
+def default_skippped_directories() -> list[str]:
+    return [
+        "prometheus-and-teams",  #  Provider registry.terraform.io/hashicorp/template v2.2.0 does not have a package available for your current platform, darwin_arm64.
+    ]
+
+
+REPO_PATH_ATLAS_ARG = typer.Argument(..., help="Path to the mongodbatlas-terraform-provider repository")
+SKIP_EXAMPLES_DIRS_OPTION = typer.Option(
+    ...,
+    "--skip-examples",
+    help="Skip example directories with these names",
+    default_factory=default_skippped_directories,
+    show_default=True,
+)
+TF_CLI_CONFIG_FILE_ENV_NAME = "TF_CLI_CONFIG_FILE"
+TF_CLI_CONFIG_FILE_ARG = typer.Option(
+    "",
+    "-tf-cli",
+    "--tf-cli-config-file",
+    envvar=TF_CLI_CONFIG_FILE_ENV_NAME,
+    help="Terraform CLI config file",
+)
+ENV_NAME_REPO_PATH_ATLAS_PROVIDER = "REPO_PATH_ATLAS_PROVIDER"
+TF_REPO_PATH_ATLAS = typer.Option(
+    "",
+    "--tf-repo-path-atlas",
+    help="Path to the mongodbatlas-terraform-provider repository",
+    envvar=ENV_NAME_REPO_PATH_ATLAS_PROVIDER,
+)

atlas_init/tf_ext/constants.py

@@ -0,0 +1,3 @@
+DEFAULT_EXTERNAL_SUBSTRINGS = ["aws", "azure", "google", "gcp"]
+DEFAULT_INTERNAL_SUBSTRINGS = ["atlas", "mongo", "aws_region", "gcp_region", "azure_region", "cidr"]
+ATLAS_PROVIDER_NAME = "mongodbatlas"