dbt-platform-helper 13.4.0__py3-none-any.whl → 14.0.0__py3-none-any.whl

dbt_platform_helper/providers/config.py

@@ -1,41 +1,59 @@
 from copy import deepcopy
+from datetime import datetime
 from pathlib import Path
 
 from schema import SchemaError
 
+from dbt_platform_helper.constants import FIRST_UPGRADABLE_PLATFORM_HELPER_MAJOR_VERSION
 from dbt_platform_helper.constants import PLATFORM_CONFIG_FILE
+from dbt_platform_helper.constants import PLATFORM_CONFIG_SCHEMA_VERSION
+from dbt_platform_helper.constants import PLATFORM_HELPER_PACKAGE_NAME
 from dbt_platform_helper.providers.config_validator import ConfigValidator
 from dbt_platform_helper.providers.config_validator import ConfigValidatorError
 from dbt_platform_helper.providers.io import ClickIOProvider
 from dbt_platform_helper.providers.platform_config_schema import PlatformConfigSchema
+from dbt_platform_helper.providers.semantic_version import SemanticVersion
+from dbt_platform_helper.providers.version import InstalledVersionProvider
 from dbt_platform_helper.providers.yaml_file import FileNotFoundException
 from dbt_platform_helper.providers.yaml_file import FileProviderException
 from dbt_platform_helper.providers.yaml_file import YamlFileProvider
 
+SCHEMA_VERSION_MESSAGE = """Installed version: platform-helper: {installed_platform_helper_version} (schema version: {installed_schema_version})
+'platform-config.yml' version: platform-helper: {config_platform_helper_version} (schema version: {config_schema_version})"""
+PLEASE_UPGRADE_TO_V13_MESSAGE = """Please ensure that you have already upgraded to platform-helper 13, following the instructions in https://platform.readme.trade.gov.uk/reference/upgrading-platform-helper/.
+
+Then upgrade platform-helper to version {installed_platform_helper_version} and run 'platform-helper config migrate' to upgrade the configuration to the current schema version."""
+
 
 class ConfigProvider:
     def __init__(
         self,
-        config_validator: ConfigValidator = None,
-        file_provider: YamlFileProvider = None,
-        io: ClickIOProvider = None,
+        config_validator: ConfigValidator = ConfigValidator(),
+        file_provider: YamlFileProvider = YamlFileProvider,
+        io: ClickIOProvider = ClickIOProvider(),
+        schema_version_for_installed_platform_helper: int = PLATFORM_CONFIG_SCHEMA_VERSION,
+        installed_version_provider: InstalledVersionProvider = InstalledVersionProvider,
     ):
         self.config = {}
-        self.validator = config_validator or ConfigValidator()
-        self.io = io or ClickIOProvider()
-        self.file_provider = file_provider or YamlFileProvider
-
-    # TODO refactor so that apply_environment_defaults isn't set, discarded and set again
+        self.validator = config_validator
+        self.io = io
+        self.file_provider = file_provider
+        self.schema_version_for_installed_platform_helper = (
+            schema_version_for_installed_platform_helper
+        )
+        self.installed_version_provider = installed_version_provider
+
+    # TODO: DBTP-1964: refactor so that apply_environment_defaults isn't set, discarded and set again
     def get_enriched_config(self):
         return self.apply_environment_defaults(self.load_and_validate_platform_config())
 
     def _validate_platform_config(self):
         PlatformConfigSchema.schema().validate(self.config)
-
-        # TODO= logically this isn't validation but loading + parsing, to move.
+        # TODO: DBTP-1964: = logically this isn't validation but loading + parsing, to move.
         # also, we apply defaults but discard that data.  Should we just apply
         # defaults to config returned by load_and_validate
         enriched_config = ConfigProvider.apply_environment_defaults(self.config)
+
         try:
             self.validator.run_validations(enriched_config)
         except ConfigValidatorError as exc:
@@ -51,6 +69,8 @@ class ConfigProvider:
         except FileProviderException as e:
             self.io.abort_with_error(f"Error loading configuration from {path}: {e}")
 
+        self._validate_schema_version()
+
         try:
             self._validate_platform_config()
         except SchemaError as e:
@@ -58,13 +78,90 @@ class ConfigProvider:
 
         return self.config
 
+    def _abort_due_to_schema_version_error(self, config_description: str, action_required: str):
+        self.io.abort_with_error(
+            "\n".join(
+                [
+                    config_description,
+                    "",
+                    action_required,
+                ]
+            )
+        )
+
+    def _validate_schema_version(self):
+        config_schema_version = self.config.get("schema_version")
+        config_platform_helper_version = self.config.get("default_versions", {}).get(
+            "platform-helper", ""
+        )
+        header = SCHEMA_VERSION_MESSAGE.format(
+            installed_platform_helper_version=self._installed_platform_helper_version(),
+            installed_schema_version=self.schema_version_for_installed_platform_helper,
+            config_platform_helper_version=(
+                config_platform_helper_version if config_platform_helper_version else "N/A"
+            ),
+            config_schema_version=(config_schema_version if config_schema_version else "N/A"),
+        )
+
+        if config_schema_version:
+            self._handle_schema_version_mismatch(config_schema_version, header)
+        else:
+            self._handle_missing_schema_version(config_platform_helper_version, header)
+
+    def _handle_schema_version_mismatch(self, platform_config_schema_version: int, header: str):
+        platform_config_schema_version_is_old = (
+            platform_config_schema_version < self.schema_version_for_installed_platform_helper
+        )
+        installed_platform_helper_is_old = (
+            platform_config_schema_version > self.schema_version_for_installed_platform_helper
+        )
+
+        if platform_config_schema_version_is_old:
+            self._abort_due_to_schema_version_error(
+                header,
+                "Please upgrade your platform-config.yml by running 'platform-helper config migrate'.",
+            )
+        elif installed_platform_helper_is_old:
+            self._abort_due_to_schema_version_error(
+                header,
+                f"Please update your platform-helper to a version that supports schema_version: {platform_config_schema_version}.",
+            )
+        # else the schema_version is the correct one so continue.
+
+    def _handle_missing_schema_version(self, config_platform_helper_version: str, header: str):
+        config_p_h_version_semver = SemanticVersion.from_string(config_platform_helper_version)
+        major_version = config_p_h_version_semver and config_p_h_version_semver.major
+        platform_config_is_old_but_supported_by_migrations = (
+            major_version and major_version == FIRST_UPGRADABLE_PLATFORM_HELPER_MAJOR_VERSION
+        )
+        platform_config_is_old = (
+            major_version and major_version < FIRST_UPGRADABLE_PLATFORM_HELPER_MAJOR_VERSION
+        )
+        platform_config_is_really_old = not major_version
+        installed_platform_helper_version = self._installed_platform_helper_version()
+
+        if platform_config_is_old_but_supported_by_migrations:
+            self._abort_due_to_schema_version_error(
+                header,
+                f"Please upgrade your platform-config.yml to be compatible with {installed_platform_helper_version} by running: 'platform-helper config migrate'.",
+            )
+        elif platform_config_is_old or platform_config_is_really_old:
+            self._abort_due_to_schema_version_error(
+                header,
+                PLEASE_UPGRADE_TO_V13_MESSAGE.format(
+                    installed_platform_helper_version=installed_platform_helper_version,
+                ),
+            )
+        # if major_version and major_version > FIRST_UPGRADABLE_PLATFORM_HELPER_MAJOR_VERSION then
+        # the platform-config.yml is malformed and so should progress to validation if appropriate.
+
     def load_unvalidated_config_file(self, path=PLATFORM_CONFIG_FILE):
         try:
             return self.file_provider.load(path)
         except FileProviderException:
             return {}
 
-    # TODO remove function and push logic to where this is called.
+    # TODO: DBTP-1888: remove function and push logic to where this is called.
     # removed usage from config domain, code is very generic and doesn't require the overhead of a function
     def config_file_check(self, path=PLATFORM_CONFIG_FILE):
         if not Path(path).exists():
@@ -86,17 +183,12 @@ class ConfigProvider:
             name: data if data else {} for name, data in environments.items() if name != "*"
         }
 
-        default_versions = config.get("default_versions", {})
+        config.get("default_versions", {})
 
         def combine_env_data(data):
             return {
                 **env_defaults,
                 **data,
-                "versions": {
-                    **default_versions,
-                    **env_defaults.get("versions", {}),
-                    **data.get("versions", {}),
-                },
             }
 
         defaulted_envs = {
@@ -107,3 +199,13 @@ class ConfigProvider:
         enriched_config["environments"] = defaulted_envs
 
         return enriched_config
+
+    def write_platform_config(self, new_platform_config):
+        current_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        message = f"# Generated by platform-helper {self._installed_platform_helper_version()} / {current_date}.\n\n"
+        self.file_provider.write(PLATFORM_CONFIG_FILE, new_platform_config, message)
+
+    def _installed_platform_helper_version(self) -> str:
+        return str(
+            self.installed_version_provider.get_semantic_version(PLATFORM_HELPER_PACKAGE_NAME)
+        )

dbt_platform_helper/providers/config_validator.py

@@ -89,16 +89,16 @@ class ConfigValidator:
         return self._validate_extension_supported_versions(
             config=config,
             aws_provider=Redis(self._get_client("elasticache")),
-            extension_type="redis",  # TODO this is information which can live in the RedisProvider
-            version_key="engine",  # TODO this is information which can live in the RedisProvider
+            extension_type="redis",  # TODO: DBTP-1888: this is information which can live in the RedisProvider
+            version_key="engine",  # TODO: DBTP-1888: this is information which can live in the RedisProvider
         )
 
     def validate_supported_opensearch_versions(self, config):
         return self._validate_extension_supported_versions(
             config=config,
             aws_provider=Opensearch(self._get_client("opensearch")),
-            extension_type="opensearch",  # TODO this is information which can live in the OpensearchProvider
-            version_key="engine",  # TODO this is information which can live in the OpensearchProvider
+            extension_type="opensearch",  # TODO: DBTP-1888: this is information which can live in the OpensearchProvider
+            version_key="engine",  # TODO: DBTP-1888: this is information which can live in the OpensearchProvider
         )
 
     def validate_environment_pipelines(self, config):
@@ -180,21 +180,6 @@ class ConfigValidator:
                 from_env = section["from"]
                 to_env = section["to"]
 
-                from_account = (
-                    config.get("environments", {})
-                    .get(from_env, {})
-                    .get("accounts", {})
-                    .get("deploy", {})
-                    .get("id")
-                )
-                to_account = (
-                    config.get("environments", {})
-                    .get(to_env, {})
-                    .get("accounts", {})
-                    .get("deploy", {})
-                    .get("id")
-                )
-
                 if from_env == to_env:
                     errors.append(
                         f"database_copy 'to' and 'from' cannot be the same environment in extension '{extension_name}'."
@@ -215,18 +200,6 @@ class ConfigValidator:
                         f"database_copy 'to' parameter must be a valid environment ({all_envs_string}) but was '{to_env}' in extension '{extension_name}'."
                     )
 
-                # TODO - The from_account and to_account properties are deprecated and will be removed when terraform-platform-modules is merged with platform-tools
-                if from_account != to_account:
-                    if "from_account" in section and section["from_account"] != from_account:
-                        errors.append(
-                            f"Incorrect value for 'from_account' for environment '{from_env}'"
-                        )
-
-                    if "to_account" in section and section["to_account"] != to_account:
-                        errors.append(
-                            f"Incorrect value for 'to_account' for environment '{to_env}'"
-                        )
-
         if errors:
             raise ConfigValidatorError("\n".join(errors))
 

dbt_platform_helper/providers/copilot.py

@@ -53,7 +53,7 @@ def create_addon_client_task(
         # We cannot check for botocore.errorfactory.NoSuchEntityException as botocore generates that class on the fly as part of errorfactory.
         # factory. Checking the error code is the recommended way of handling these exceptions.
         if ex.response.get("Error", {}).get("Code", None) != "NoSuchEntity":
-            # TODO When we are refactoring this, raise an exception to be caught at the command layer
+            # TODO: DBTP-1946: When we are refactoring this, raise an exception to be caught at the command layer
             abort_with_error(
                 f"cannot obtain Role {role_name}: {ex.response.get('Error', {}).get('Message', '')}"
             )
@@ -132,7 +132,7 @@ def connect_to_addon_client_task(
     tries = 0
     while tries < 15 and not running:
         tries += 1
-        # Todo: Use from ECS provider when we refactor this
+        # TODO: DBTP-1946: Use from ECS provider when we refactor this
         if get_ecs_task_arns(ecs_client, cluster_arn, task_name):
             subprocess.call(
                 "copilot task exec "
@@ -154,7 +154,7 @@ def _normalise_secret_name(addon_name: str) -> str:
 
 
 def _get_secrets_provider(application: Application, env: str) -> Secrets:
-    # Todo: We instantiate the secrets provider here to avoid rabbit holing, but something better probably possible when we are refactoring this area
+    # TODO: DBTP-1946: We instantiate the secrets provider here to avoid rabbit holing, but something better probably possible when we are refactoring this area
     return Secrets(
         application.environments[env].session.client("ssm"),
         application.environments[env].session.client("secretsmanager"),

dbt_platform_helper/providers/io.py

@@ -29,7 +29,7 @@ class ClickIOProvider:
         click.secho(f"Error: {message}", err=True, fg="red")
         exit(1)
 
-    # TODO messages will be a ValidationMessages class rather than a free-rein dictionary
+    # TODO: DBTP-1979: messages will be a ValidationMessages class rather than a free-rein dictionary
     def process_messages(self, messages: dict):
         if not messages:
             return

dbt_platform_helper/providers/load_balancers.py

@@ -48,7 +48,7 @@ class LoadBalancerProvider:
             ResourceTypeFilters=[
                 "elasticloadbalancing:targetgroup",
             ],
-        )  # TODO should be paginated
+        )  # TODO: DBTP-1942: should be paginated
         for resource in response["ResourceTagMappingList"]:
             tags = {tag["Key"]: tag["Value"] for tag in resource["Tags"]}
 
@@ -73,7 +73,7 @@ class LoadBalancerProvider:
         listener_arn = self.get_https_listener_for_application(app, env)
         certificates = self.evlb_client.describe_listener_certificates(ListenerArn=listener_arn)[
             "Certificates"
-        ]  # TODO should be paginated
+        ]  # TODO: DBTP-1942: should be paginated
 
         try:
             certificate_arn = next(c["CertificateArn"] for c in certificates if c["IsDefault"])
@@ -87,7 +87,7 @@ class LoadBalancerProvider:
 
         listeners = self.evlb_client.describe_listeners(LoadBalancerArn=load_balancer_arn)[
             "Listeners"
-        ]  # TODO should be paginated
+        ]  # TODO: DBTP-1942: should be paginated
 
         listener_arn = None
 
@@ -114,7 +114,7 @@ class LoadBalancerProvider:
 
         for lb in tag_descriptions:
             tags = {t["Key"]: t["Value"] for t in lb["Tags"]}
-            # TODO copilot hangover, creates coupling to specific tags could update to check application and environment
+            # TODO: DBTP-1967: copilot hangover, creates coupling to specific tags could update to check application and environment
             if tags.get("copilot-application") == app and tags.get("copilot-environment") == env:
                 return lb["ResourceArn"]
 
@@ -123,7 +123,7 @@ class LoadBalancerProvider:
     def get_host_header_conditions(self, listener_arn: str, target_group_arn: str) -> list:
         rules = self.evlb_client.describe_rules(ListenerArn=listener_arn)[
             "Rules"
-        ]  # TODO should be paginated
+        ]  # TODO: DBTP-1942: should be paginated
 
         conditions = []
 
@@ -152,7 +152,7 @@ class LoadBalancerProvider:
     def get_rules_tag_descriptions_by_listener_arn(self, listener_arn: str) -> list:
         rules = self.evlb_client.describe_rules(ListenerArn=listener_arn)[
             "Rules"
-        ]  # TODO should be paginated
+        ]  # TODO: DBTP-1942: should be paginated
         return self.get_rules_tag_descriptions(rules)
 
     def get_rules_tag_descriptions(self, rules: list) -> list:

dbt_platform_helper/providers/platform_config_schema.py

@@ -8,15 +8,18 @@ from schema import Regex
 from schema import Schema
 from schema import SchemaError
 
+from dbt_platform_helper.constants import PLATFORM_CONFIG_SCHEMA_VERSION
+
 
 class PlatformConfigSchema:
     @staticmethod
     def schema() -> Schema:
         return Schema(
             {
+                "schema_version": PLATFORM_CONFIG_SCHEMA_VERSION,
                 "application": str,
                 Optional("deploy_repository"): str,
-                Optional("default_versions"): PlatformConfigSchema.__default_versions_schema(),
+                "default_versions": PlatformConfigSchema.__default_versions_schema(),
                 Optional("environments"): PlatformConfigSchema.__environments_schema(),
                 Optional("codebase_pipelines"): PlatformConfigSchema.__codebase_pipelines_schema(),
                 Optional(
@@ -55,7 +58,7 @@ class PlatformConfigSchema:
             "subscription-filter": PlatformConfigSchema.__no_configuration_required_schema(
                 "subscription-filter"
             ),
-            # Todo: The next three are no longer relevant. Remove them.
+            # TODO: DBTP-1943: The next three are no longer relevant. Remove them.
             "monitoring": Schema(PlatformConfigSchema.__monitoring_schema()),
             "vpc": PlatformConfigSchema.__no_configuration_required_schema("vpc"),
             "xray": PlatformConfigSchema.__no_configuration_required_schema("xray"),
@@ -166,16 +169,11 @@ class PlatformConfigSchema:
     @staticmethod
     def __default_versions_schema() -> dict:
         return {
-            Optional("terraform-platform-modules"): str,
-            Optional("platform-helper"): str,
+            "platform-helper": str,
         }
 
     @staticmethod
     def __environments_schema() -> dict:
-        _valid_environment_specific_version_overrides = {
-            Optional("terraform-platform-modules"): str,
-        }
-
         return {
             str: Or(
                 None,
@@ -190,9 +188,8 @@ class PlatformConfigSchema:
                             "id": str,
                         },
                     },
-                    # Todo: requires_approval is no longer relevant since we don't have AWS Copilot manage environment pipelines
+                    # TODO: DBTP-1943: requires_approval is no longer relevant since we don't have AWS Copilot manage environment pipelines
                     Optional("requires_approval"): bool,
-                    Optional("versions"): _valid_environment_specific_version_overrides,
                     Optional("vpc"): str,
                 },
             )
@@ -250,7 +247,7 @@ class PlatformConfigSchema:
 
     @staticmethod
     def __opensearch_schema() -> dict:
-        # Todo: Move to OpenSearch provider?
+        # TODO: DBTP-1943: Move to OpenSearch provider?
         _valid_opensearch_plans = Or(
             "tiny",
             "small",
@@ -288,7 +285,7 @@ class PlatformConfigSchema:
 
     @staticmethod
     def __postgres_schema() -> dict:
-        # Todo: Move to Postgres provider?
+        # TODO: DBTP-1943: Move to Postgres provider?
         _valid_postgres_plans = Or(
             "tiny",
             "small",
@@ -311,14 +308,12 @@ class PlatformConfigSchema:
             "4x-large-high-io",
         )
 
-        # Todo: Move to Postgres provider?
+        # TODO: DBTP-1943: Move to Postgres provider?
         _valid_postgres_storage_types = Or("gp2", "gp3", "io1", "io2")
 
         _valid_postgres_database_copy = {
             "from": PlatformConfigSchema.__valid_environment_name(),
             "to": PlatformConfigSchema.__valid_environment_name(),
-            Optional("from_account"): str,
-            Optional("to_account"): str,
             Optional("pipeline"): {Optional("schedule"): str},
         }
 
@@ -366,7 +361,7 @@ class PlatformConfigSchema:
 
     @staticmethod
     def __redis_schema() -> dict:
-        # Todo move to Redis provider?
+        # TODO: DBTP-1943: move to Redis provider?
         _valid_redis_plans = Or(
             "micro",
             "micro-ha",
@@ -400,7 +395,7 @@ class PlatformConfigSchema:
 
     @staticmethod
     def valid_s3_bucket_name(name: str):
-        # Todo: This is a public method becasue that's what the test expect. Perhaps it belongs in an S3 provider?
+        # TODO: DBTP-1943: This is a public method becasue that's what the test expect. Perhaps it belongs in an S3 provider?
         errors = []
         if not (2 < len(name) < 64):
             errors.append("Length must be between 3 and 63 characters inclusive.")
@@ -429,9 +424,9 @@ class PlatformConfigSchema:
                 errors.append(f"Names cannot be suffixed '{suffix}'.")
 
         if errors:
-            # Todo: Raise suitable PlatformException?
+            # TODO: DBTP-1943: Raise suitable PlatformException?
             raise SchemaError(
-                "Bucket name '{}' is invalid:\n{}".format(name, "\n".join(f"  {e}" for e in errors))
+                f"Bucket name '{name}' is invalid:\n" + "\n".join(f"  {e}" for e in errors)
             )
 
         return True
@@ -557,10 +552,10 @@ class PlatformConfigSchema:
 
     @staticmethod
     def string_matching_regex(regex_pattern: str) -> Callable:
-        # Todo public for the unit tests, not sure about testing what could be a private method. Perhaps it's covered by other tests anyway?
+        # TODO: DBTP-1943: public for the unit tests, not sure about testing what could be a private method. Perhaps it's covered by other tests anyway?
         def validate(string):
             if not re.match(regex_pattern, string):
-                # Todo: Raise suitable PlatformException?
+                # TODO: DBTP-1943: Raise suitable PlatformException?
                 raise SchemaError(
                     f"String '{string}' does not match the required pattern '{regex_pattern}'."
                 )
@@ -570,11 +565,11 @@ class PlatformConfigSchema:
 
     @staticmethod
     def is_integer_between(lower_limit, upper_limit) -> Callable:
-        # Todo public for the unit tests, not sure about testing what could be a private method. Perhaps it's covered by other tests anyway?
+        # TODO: DBTP-1943: public for the unit tests, not sure about testing what could be a private method. Perhaps it's covered by other tests anyway?
         def validate(value):
             if isinstance(value, int) and lower_limit <= value <= upper_limit:
                 return True
-            # Todo: Raise suitable PlatformException?
+            # TODO: DBTP-1943: Raise suitable PlatformException?
             raise SchemaError(f"should be an integer between {lower_limit} and {upper_limit}")
 
         return validate
@@ -588,7 +583,7 @@ class PlatformConfigSchema:
 
     @staticmethod
     def __valid_branch_name() -> Callable:
-        # Todo: Make this actually validate a git branch name properly; https://git-scm.com/docs/git-check-ref-format
+        # TODO: DBTP-1943: Make this actually validate a git branch name properly; https://git-scm.com/docs/git-check-ref-format
         return PlatformConfigSchema.string_matching_regex(r"^((?!\*).)*(\*)?$")
 
     @staticmethod
@@ -634,10 +629,10 @@ class PlatformConfigSchema:
 
 
 class ConditionalOpensSearchSchema(Schema):
-    # Todo: Move to OpenSearch provider?
+    # TODO: DBTP-1943: Move to OpenSearch provider?
     _valid_opensearch_min_volume_size: int = 10
 
-    # Todo: Move to OpenSearch provider?
+    # TODO: DBTP-1943: Move to OpenSearch provider?
     _valid_opensearch_max_volume_size: dict = {
         "tiny": 100,
         "small": 200,
@@ -671,11 +666,11 @@ class ConditionalOpensSearchSchema(Schema):
 
                 if volume_size:
                     if not plan:
-                        # Todo: Raise suitable PlatformException?
+                        # TODO: DBTP-1943: Raise suitable PlatformException?
                         raise SchemaError(f"Missing key: 'plan'")
 
                     if volume_size < self._valid_opensearch_min_volume_size:
-                        # Todo: Raise suitable PlatformException?
+                        # TODO: DBTP-1943: Raise suitable PlatformException?
                         raise SchemaError(
                             f"Key 'environments' error: Key '{env}' error: Key 'volume_size' error: should be an integer greater than {self._valid_opensearch_min_volume_size}"
                         )
@@ -685,7 +680,7 @@ class ConditionalOpensSearchSchema(Schema):
                             plan == key
                             and not volume_size <= self._valid_opensearch_max_volume_size[key]
                         ):
-                            # Todo: Raise suitable PlatformException?
+                            # TODO: DBTP-1943: Raise suitable PlatformException?
                             raise SchemaError(
                                 f"Key 'environments' error: Key '{env}' error: Key 'volume_size' error: should be an integer between {self._valid_opensearch_min_volume_size} and {self._valid_opensearch_max_volume_size[key]} for plan {plan}"
                             )

dbt_platform_helper/providers/schema_migrations/schema_v0_to_v1_migration.py

@@ -0,0 +1,43 @@
+from copy import deepcopy
+
+
+class SchemaV0ToV1Migration:
+    def from_version(self) -> int:
+        return 0
+
+    def migrate(self, platform_config: dict) -> dict:
+        migrated_config = deepcopy(platform_config)
+
+        self._remove_terraform_platform_modules_default_version(migrated_config)
+        self._remove_versions_from_env_config(migrated_config)
+        self._remove_to_account_and_from_account_from_database_copy(migrated_config)
+        self._remove_pipeline_platform_helper_override(migrated_config)
+
+        return migrated_config
+
+    def _remove_versions_from_env_config(self, migrated_config: dict) -> None:
+        for env_name, env in migrated_config.get("environments", {}).items():
+            if env and "versions" in env:
+                del env["versions"]
+
+    def _remove_terraform_platform_modules_default_version(self, migrated_config: dict) -> None:
+        if "default_versions" in migrated_config:
+            default_versions = migrated_config["default_versions"]
+            if "terraform-platform-modules" in default_versions:
+                del default_versions["terraform-platform-modules"]
+
+    def _remove_to_account_and_from_account_from_database_copy(self, migrated_config: dict) -> None:
+        for extension_name, extension in migrated_config.get("extensions", {}).items():
+            if extension.get("type") == "postgres" and "database_copy" in extension:
+                for database_copy_block in extension["database_copy"]:
+                    if "from_account" in database_copy_block:
+                        del database_copy_block["from_account"]
+                    if "to_account" in database_copy_block:
+                        del database_copy_block["to_account"]
+
+    def _remove_pipeline_platform_helper_override(self, migrated_config: dict) -> None:
+        for pipeline_name, pipeline_config in migrated_config.get(
+            "environment_pipelines", {}
+        ).items():
+            if "versions" in pipeline_config:
+                del pipeline_config["versions"]

dbt_platform_helper/providers/schema_migrator.py

@@ -0,0 +1,77 @@
+from collections import Counter
+from collections import OrderedDict
+from copy import deepcopy
+from typing import Protocol
+
+from dbt_platform_helper.platform_exception import PlatformException
+from dbt_platform_helper.providers.io import ClickIOProvider
+from dbt_platform_helper.providers.schema_migrations.schema_v0_to_v1_migration import (
+    SchemaV0ToV1Migration,
+)
+from dbt_platform_helper.providers.version import InstalledVersionProvider
+
+
+class InvalidMigrationConfigurationException(PlatformException):
+    pass
+
+
+class SchemaMigrationProtocol(Protocol):
+    def from_version(self) -> int: ...
+
+    def migrate(self, platform_config: dict) -> dict: ...
+
+
+# TODO: Possibly get this programmatically?
+ALL_MIGRATIONS = [SchemaV0ToV1Migration()]
+
+
+class Migrator:
+    def __init__(
+        self,
+        migrations: list[SchemaMigrationProtocol],
+        installed_version_provider: InstalledVersionProvider = InstalledVersionProvider,
+        io_provider: ClickIOProvider = ClickIOProvider(),
+    ):
+        self.migrations = sorted(migrations, key=lambda m: m.from_version())
+        self.installed_version_provider = installed_version_provider
+        self.io_provider = io_provider
+        from_version_counts = Counter([migration.from_version() for migration in self.migrations])
+        duplicate_from_versions = [count for count in from_version_counts.values() if count > 1]
+
+        if duplicate_from_versions:
+            raise InvalidMigrationConfigurationException(
+                "`from_version` parameters must be unique amongst migrations"
+            )
+
+    def migrate(self, platform_config: dict) -> dict:
+        out = OrderedDict(deepcopy(platform_config))
+        if "schema_version" not in out:
+            out["schema_version"] = 0
+
+        if "default_versions" in out:
+            out.move_to_end("default_versions", last=False)
+        if "schema_version" in out:
+            out.move_to_end("schema_version", last=False)
+        if "application" in out:
+            out.move_to_end("application", last=False)
+
+        for migration in self.migrations:
+            migration_can_be_applied = migration.from_version() == out["schema_version"]
+            if migration_can_be_applied:
+                out = migration.migrate(out)
+                schema_version = out["schema_version"]
+                self.io_provider.info(
+                    f"Migrating from platform config schema version {schema_version} to version {schema_version + 1}"
+                )
+                out["schema_version"] += 1
+
+        if "default_versions" not in out:
+            out["default_versions"] = {}
+
+        out["default_versions"]["platform-helper"] = str(
+            self.installed_version_provider.get_semantic_version("dbt-platform-helper")
+        )
+
+        self.io_provider.info("\nMigration complete")
+
+        return dict(out)