feat: ORM-1263 external enums (#5559)

Add support for externally managed enums analog to external tables.
Effectively only really required on Postgres as enums are dedicated
database entities there.

Author: FGoessler

schema-engine/connectors/schema-connector/src/filter.rs

@@ -9,10 +9,14 @@ pub struct SchemaFilter {
     /// Prisma will not consider those tables during diffing operations, migration creation, or introspection.
     /// They are still available for querying at runtime.
     pub external_tables: Vec<String>,
+    /// Enums that shall be considered "externally" managed. As per prisma.config.ts > enums.external.
+    /// Prisma will not consider those enums during diffing operations, migration creation, or introspection.
+    /// They are still available for querying at runtime.
+    pub external_enums: Vec<String>,
 }
 
 impl SchemaFilter {
-    /// Validate that the schema filter contains correctly qualified table names.
+    /// Validate that the schema filter contains correctly qualified table and enum names.
     pub fn validate(&self, namespaces: Option<&Namespaces>) -> ConnectorResult<()> {
         let has_explicit_namespaces = namespaces.is_some();
 
@@ -24,6 +28,14 @@ impl SchemaFilter {
             }
         }
 
+        for enum_name in self.external_enums.iter() {
+            if has_explicit_namespaces && !enum_name.contains(".") {
+                return Err(ConnectorError::user_facing(MissingNamespaceInExternalTables));
+            } else if !has_explicit_namespaces && enum_name.contains(".") {
+                return Err(ConnectorError::user_facing(UnexpectedNamespaceInExternalTables));
+            }
+        }
+
         Ok(())
     }
 }
@@ -32,14 +44,17 @@ impl From<json_rpc::types::SchemaFilter> for SchemaFilter {
     fn from(filter: json_rpc::types::SchemaFilter) -> Self {
         Self {
             external_tables: filter.external_tables,
+            external_enums: filter.external_enums,
         }
     }
 }
 
 impl From<Option<json_rpc::types::SchemaFilter>> for SchemaFilter {
     fn from(filter: Option<json_rpc::types::SchemaFilter>) -> Self {
+        let filter = filter.unwrap_or_default();
         Self {
-            external_tables: filter.map(|f| f.external_tables).unwrap_or_default(),
+            external_tables: filter.external_tables,
+            external_enums: filter.external_enums,
         }
     }
 }

schema-engine/connectors/sql-schema-connector/src/sql_schema_differ/differ_database.rs

@@ -353,12 +353,25 @@ impl<'a> DifferDatabase<'a> {
         all_tables_are_external && !has_enums
     }
 
+    fn is_enum_external(&self, enum_walker: &EnumWalker<'_>) -> bool {
+        self.flavour
+            .contains_table(&self.filter.external_enums, enum_walker.namespace(), enum_walker.name())
+    }
+
     fn previous_enums(&self) -> impl Iterator<Item = EnumWalker<'a>> {
-        self.schemas.previous.describer_schema.enum_walkers()
+        self.schemas
+            .previous
+            .describer_schema
+            .enum_walkers()
+            .filter(|e| !self.is_enum_external(e))
     }
 
     fn next_enums(&self) -> impl Iterator<Item = EnumWalker<'a>> {
-        self.schemas.next.describer_schema.enum_walkers()
+        self.schemas
+            .next
+            .describer_schema
+            .enum_walkers()
+            .filter(|e| !self.is_enum_external(e))
     }
 
     fn previous_extensions(&self) -> impl Iterator<Item = ExtensionWalker<'a>> {

schema-engine/json-rpc-api/src/types.rs

@@ -96,6 +96,8 @@ pub struct SchemasWithConfigDir {
 pub struct SchemaFilter {
     /// Tables that shall be considered 'externally" managed. As per prisma.config.ts > tables.external.
     pub external_tables: Vec<String>,
+    /// Enums that shall be considered "externally" managed. As per prisma.config.ts > enums.external.
+    pub external_enums: Vec<String>,
 }
 
 /// The path to a live database taken as input. For flexibility, this can be Prisma schemas as strings, or only the

schema-engine/sql-migration-tests/tests/migrations/diff.rs

@@ -720,6 +720,7 @@ fn with_schema_filters(mut api: TestApi) {
         to: DiffTarget::Url(UrlContainer { url: second_url }),
         filters: Some(SchemaFilter {
             external_tables: vec!["external_table".to_string()],
+            external_enums: vec![],
         }),
     };
 
@@ -769,6 +770,7 @@ fn with_invalid_schema_filters(mut api: TestApi) {
         to: DiffTarget::Url(UrlContainer { url: second_url }),
         filters: Some(SchemaFilter {
             external_tables: vec!["public.external_table".to_string()],
+            external_enums: vec![],
         }),
     };
 

schema-engine/sql-migration-tests/tests/migrations/migration_persistence_tests.rs

@@ -204,6 +204,7 @@ fn starting_a_migration_on_db_with_existing_external_table_does_not_errors(api:
         None,
         SchemaFilter {
             external_tables: vec!["cats".to_string()],
+            external_enums: vec![],
         },
     ));
 

schema-engine/sql-migration-tests/tests/migrations/schema_filter.rs

@@ -16,10 +16,13 @@ fn schema_filter_migration_adding_external_table(api: TestApi) {
 
     let filter = SchemaFilter {
         external_tables: vec!["ExternalTable".to_string()],
+        external_enums: vec![],
     };
     api.create_migration_with_filter("custom", &schema, &dir, filter, "")
         .send_sync()
         .assert_migration_directories_count(0);
+    // Table is external => migrations should not touch it => created no migration => external table should not be there
+    api.assert_schema().assert_has_no_table("ExternalTable");
 }
 
 #[test_connector]
@@ -32,20 +35,21 @@ fn schema_filter_migration_removing_external_table(mut api: TestApi) {
         }
     "#,
     );
-
-    let dir = api.create_migrations_directory();
-
     // No filter applied here to actually create the external tables first
-    api.create_migration("create", &schema_1, &dir).send_sync();
+    api.schema_push(schema_1).send();
 
+    let dir = api.create_migrations_directory();
     let schema_2 = api.datamodel_with_provider("");
 
     let filter = SchemaFilter {
         external_tables: vec!["ExternalTable".to_string()],
+        external_enums: vec![],
     };
     api.create_migration_with_filter("remove", &schema_2, &dir, filter, "")
         .send_sync()
-        .assert_migration_directories_count(1);
+        .assert_migration_directories_count(0);
+    // Table is external => migrations should not touch it => created no migration => external table should still be there
+    api.assert_schema().assert_has_table("ExternalTable");
 }
 
 #[test_connector]
@@ -58,20 +62,17 @@ fn schema_filter_migration_removing_external_table_with_contents(mut api: TestAp
         }
     "#,
     );
-
-    let dir = api.create_migrations_directory();
-
     // No filter applied here to actually create the external tables first
-    api.create_migration("create", &schema_1, &dir).send_sync();
-    api.apply_migrations(&dir).send_sync();
-
+    api.schema_push(schema_1).send();
     api.insert("Cat").value("id", 1).value("name", "Felix").result_raw();
     api.insert("Cat").value("id", 2).value("name", "Norbert").result_raw();
 
+    let dir = api.create_migrations_directory();
     let schema_2 = api.datamodel_with_provider("");
 
     let filter = SchemaFilter {
         external_tables: vec!["Cat".to_string()],
+        external_enums: vec![],
     };
     api.evaluate_data_loss_with_filter(&dir, schema_2.clone(), filter)
         .send()
@@ -87,12 +88,10 @@ fn schema_filter_migration_modifying_external_table(mut api: TestApi) {
         }
     "#,
     );
-
-    let dir = api.create_migrations_directory();
-
     // No filter applied here to actually create the external tables first
-    api.create_migration("create", &schema_1, &dir).send_sync();
+    api.schema_push(schema_1).send();
 
+    let dir = api.create_migrations_directory();
     let schema_2 = api.datamodel_with_provider(
         r#"
             model ExternalTable {
@@ -104,10 +103,69 @@ fn schema_filter_migration_modifying_external_table(mut api: TestApi) {
 
     let filter = SchemaFilter {
         external_tables: vec!["ExternalTable".to_string()],
+        external_enums: vec![],
     };
     api.create_migration_with_filter("modify", &schema_2, &dir, filter, "")
         .send_sync()
-        .assert_migration_directories_count(1);
+        .assert_migration_directories_count(0);
+    // Table is external => migrations should not touch it => created no migration => external table should still be in the old state
+    api.assert_schema().assert_table("ExternalTable", |table_assertions| {
+        table_assertions.assert_column_count(1)
+    });
+}
+
+#[test_connector(tags(Postgres), exclude(CockroachDb))]
+fn schema_filter_migration_adding_external_enum(api: TestApi) {
+    let schema = api.datamodel_with_provider(
+        r#"
+        enum ExternalEnum {
+            ONE
+            TWO
+        }
+    "#,
+    );
+
+    let dir = api.create_migrations_directory();
+
+    let filter = SchemaFilter {
+        external_tables: vec![],
+        external_enums: vec!["ExternalEnum".to_string()],
+    };
+    api.create_migration_with_filter("custom", &schema, &dir, filter, "")
+        .send_sync()
+        .assert_migration_directories_count(0);
+    // Enum is external => migrations should not touch it => created no migration => external enum should not be there
+    api.assert_schema().assert_has_no_enum("ExternalEnum");
+}
+
+#[test_connector(tags(Postgres), exclude(CockroachDb))]
+fn schema_filter_migration_removing_external_enum(mut api: TestApi) {
+    let schema_1 = api.datamodel_with_provider(
+        r#"
+        enum ExternalEnum {
+            ONE
+            TWO
+        }
+    "#,
+    );
+    // Create the external enum in the database
+    api.schema_push(schema_1).send();
+
+    let dir = api.create_migrations_directory();
+
+    let schema_2 = api.datamodel_with_provider("");
+
+    let filter = SchemaFilter {
+        external_tables: vec![],
+        external_enums: vec!["ExternalEnum".to_string()],
+    };
+    api.create_migration_with_filter("remove", &schema_2, &dir, filter, "")
+        .send_sync()
+        .assert_migration_directories_count(0);
+    // Enum is external => migrations should not touch it => created no migration => external enum should still be there
+    api.assert_schema().assert_enum("ExternalEnum", |enum_assertions| {
+        enum_assertions.assert_values(&["ONE", "TWO"])
+    });
 }
 
 #[test_connector(exclude(CockroachDb, Vitess))]
@@ -152,6 +210,7 @@ fn schema_filter_migration_adding_external_tables_incl_relations(api: TestApi) {
 
     let filter = SchemaFilter {
         external_tables: vec!["ExternalTableA".to_string(), "ExternalTableB".to_string()],
+        external_enums: vec![],
     };
     api.create_migration_with_filter("custom", &schema, &dir, filter, "")
         .send_sync()
@@ -283,6 +342,7 @@ fn schema_filter_migration_removing_external_tables_incl_relations(mut api: Test
 
     let filter = SchemaFilter {
         external_tables: vec!["ExternalTableA".to_string(), "ExternalTableB".to_string()],
+        external_enums: vec![],
     };
     api.create_migration_with_filter("remove", &schema_2, &dir, filter, "")
         .send_sync()
@@ -436,6 +496,7 @@ fn schema_filter_migration_modifying_external_tables_incl_relations(mut api: Tes
 
     let filter = SchemaFilter {
         external_tables: vec!["ExternalTableA".to_string(), "ExternalTableB".to_string()],
+        external_enums: vec![],
     };
     api.create_migration_with_filter("modify", &schema_2, &dir, filter, "")
         .send_sync()
@@ -542,6 +603,7 @@ fn schema_filter_leveraging_init_script(api: TestApi) {
 
     let filter = SchemaFilter {
         external_tables: vec!["external".to_string()],
+        external_enums: vec![],
     };
     api.create_migration_with_filter("custom", &schema, &dir, filter, init_script)
         .send_sync()
@@ -652,6 +714,7 @@ fn schema_filter_migration_multi_schema_requires_namespaced_table_names(api: Tes
 
     let filter = SchemaFilter {
         external_tables: vec!["two.ExternalTable".to_string()],
+        external_enums: vec![],
     };
     api.create_migration_with_filter("custom", &schema, &dir, filter, "")
         .send_sync()
@@ -731,6 +794,7 @@ fn schema_filter_migration_multi_schema_without_namespaced_table_names(api: Test
 
     let filter = SchemaFilter {
         external_tables: vec!["ExternalTable".to_string()],
+        external_enums: vec![],
     };
     let err = api
         .create_migration_with_filter("custom", &schema, &dir, filter, "")
@@ -763,6 +827,7 @@ fn schema_filter_migration_with_namespaced_table_names_and_no_explicit_schemas_l
 
     let filter = SchemaFilter {
         external_tables: vec!["public.ExternalTable".to_string()],
+        external_enums: vec![],
     };
     let err = api
         .create_migration_with_filter("custom", &schema, &dir, filter, "")
@@ -785,6 +850,7 @@ fn schema_filter_migration_dev_diagnostic_drift_detection(api: TestApi) {
 
     let filter = SchemaFilter {
         external_tables: vec!["external_table".to_string()],
+        external_enums: vec![],
     };
     // Table exists in DB and is missing in the schema but is marked as external => not a drift.
     api.dev_diagnostic_with_filter(&dir, filter)

schema-engine/sql-migration-tests/tests/migrations/soft_resets.rs

@@ -273,6 +273,7 @@ fn soft_resets_does_not_drop_external_tables(mut api: TestApi) {
         .soft(true)
         .filter(SchemaFilter {
             external_tables: vec!["external_table".to_string()],
+            external_enums: vec![],
         })
         .send_sync(None);
 

schema-engine/sql-migration-tests/tests/schema_push/mod.rs

@@ -473,6 +473,7 @@ fn schema_push_with_schema_filters(api: TestApi) {
         dm,
         Some(SchemaFilter {
             external_tables: vec!["ExternalTable".to_string()],
+            external_enums: vec![],
         }),
     )
     .send()
@@ -501,6 +502,7 @@ fn schema_push_with_invalid_schema_filters(api: TestApi) {
             dm,
             Some(SchemaFilter {
                 external_tables: vec!["public.ExternalTable".to_string()],
+                external_enums: vec![],
             }),
         )
         .send_unwrap_err();