wip

introspection-engine/connectors/sql-introspection-connector/src/calculate_datamodel.rs

@@ -1,14 +1,20 @@
 use crate::{
     introspection::introspect,
     introspection_helpers::{is_new_migration_table, is_old_migration_table, is_prisma_join_table, is_relay_table},
-    pair::{EnumPair, ModelPair, Pair},
+    introspection_map::RelationName,
+    pair::{EnumPair, ModelPair, Pair, RelationFieldDirection},
     warnings, EnumVariantName, IntrospectedName, ModelName, SqlFamilyTrait, SqlIntrospectionResult,
 };
 use introspection_connector::{IntrospectionContext, IntrospectionResult, Version, Warning};
-use psl::{builtin_connectors::*, datamodel_connector::Connector, parser_database::walkers, Configuration};
+use psl::{
+    builtin_connectors::*,
+    datamodel_connector::Connector,
+    parser_database::{ast, walkers},
+    Configuration,
+};
 use quaint::prelude::SqlFamily;
 use sql_schema_describer as sql;
-use std::collections::HashMap;
+use std::{borrow::Cow, collections::HashMap};
 
 #[derive(Debug, Default)]
 pub(crate) struct Warnings {
@@ -23,6 +29,7 @@ pub(crate) struct Warnings {
     pub(crate) reintrospected_id_names: Vec<warnings::Model>,
     pub(crate) unsupported_types: Vec<warnings::ModelAndFieldAndType>,
     pub(crate) remapped_models: Vec<warnings::Model>,
+    pub(crate) reintrospected_relations: Vec<warnings::Model>,
 }
 
 impl Warnings {
@@ -104,6 +111,12 @@ impl Warnings {
             &mut self.warnings,
         );
 
+        maybe_warn(
+            &self.reintrospected_relations,
+            warnings::warning_relations_added_from_the_previous_data_model,
+            &mut self.warnings,
+        );
+
         std::mem::take(&mut self.warnings)
     }
 }
@@ -116,7 +129,7 @@ pub(crate) struct InputContext<'a> {
     pub(crate) sql_family: SqlFamily,
     pub(crate) version: Version,
     pub(crate) previous_schema: &'a psl::ValidatedSchema,
-    pub(crate) introspection_map: &'a crate::introspection_map::IntrospectionMap,
+    pub(crate) introspection_map: &'a crate::introspection_map::IntrospectionMap<'a>,
 }
 
 pub(crate) struct OutputContext<'a> {
@@ -260,14 +273,81 @@ impl<'a> InputContext<'a> {
             // Failing that, potentially sanitize the table name.
             .unwrap_or_else(|| ModelName::new_from_sql(self.schema.walk(id).name()))
     }
+
+    pub(crate) fn forward_inline_relation_field_prisma_name(self, id: sql::ForeignKeyId) -> &'a str {
+        let existing_relation = self
+            .existing_inline_relation(id)
+            .and_then(|relation| relation.as_complete());
+
+        match existing_relation {
+            Some(relation) => relation.referencing_field().name(),
+            None => &self.inline_relation_name(id).unwrap()[1],
+        }
+    }
+
+    pub(crate) fn back_inline_relation_field_prisma_name(self, id: sql::ForeignKeyId) -> &'a str {
+        let existing_relation = self
+            .existing_inline_relation(id)
+            .and_then(|relation| relation.as_complete());
+
+        match existing_relation {
+            Some(relation) => relation.referenced_field().name(),
+            None => &self.inline_relation_name(id).unwrap()[2],
+        }
+    }
+
+    pub(crate) fn inline_relation_prisma_name(self, id: sql::ForeignKeyId) -> Cow<'a, str> {
+        let existing_relation = self
+            .existing_inline_relation(id)
+            .and_then(|relation| relation.as_complete());
+
+        match existing_relation {
+            Some(relation) => match relation.referenced_field().relation_name() {
+                walkers::RelationName::Explicit(name) => Cow::Borrowed(name),
+                walkers::RelationName::Generated(name) => Cow::Owned(name),
+            },
+            None => Cow::Borrowed(&self.inline_relation_name(id).unwrap()[0]),
+        }
+    }
+
+    pub(crate) fn inline_relation_name(self, id: sql::ForeignKeyId) -> Option<&'a RelationName<'a>> {
+        self.introspection_map.relation_names.inline_relation_name(id)
+    }
+
+    pub(crate) fn m2m_relation_name(self, id: sql::TableId) -> &'a RelationName<'a> {
+        self.introspection_map.relation_names.m2m_relation_name(id)
+    }
+
+    pub(crate) fn table_missing_for_model(self, id: &ast::ModelId) -> bool {
+        self.introspection_map.missing_tables_for_previous_models.contains(id)
+    }
+
+    pub(crate) fn inline_relations_for_table(
+        self,
+        table_id_filter: sql::TableId,
+    ) -> impl Iterator<Item = (RelationFieldDirection, sql::ForeignKeyWalker<'a>)> {
+        self.introspection_map
+            .inline_relation_positions
+            .iter()
+            .filter(move |(table_id, _, _)| *table_id == table_id_filter)
+            .filter(move |(_, fk_id, _)| self.inline_relation_name(*fk_id).is_some())
+            .map(|(_, fk_id, direction)| {
+                let foreign_key = sql::Walker {
+                    id: *fk_id,
+                    schema: self.schema,
+                };
+
+                (*direction, foreign_key)
+            })
+    }
 }
 
 /// Calculate a data model from a database schema.
 pub fn calculate_datamodel(
     schema: &sql::SqlSchema,
     ctx: &IntrospectionContext,
 ) -> SqlIntrospectionResult<IntrospectionResult> {
-    let introspection_map = crate::introspection_map::IntrospectionMap::new(schema, ctx.previous_schema());
+    let introspection_map = Default::default();
 
     let mut input = InputContext {
         version: Version::NonPrisma,
@@ -279,6 +359,9 @@ pub fn calculate_datamodel(
         introspection_map: &introspection_map,
     };
 
+    let introspection_map = crate::introspection_map::IntrospectionMap::new(input);
+    input.introspection_map = &introspection_map;
+
     let mut output = OutputContext {
         rendered_schema: datamodel_renderer::Datamodel::default(),
         target_models: HashMap::default(),

introspection-engine/connectors/sql-introspection-connector/src/introspection.rs

@@ -1,13 +1,10 @@
-pub(crate) mod inline_relations;
-
 mod configuration;
 mod enums;
 mod indexes;
 mod m2m_relations;
 mod models;
 mod postgres;
-mod prisma_relation_mode;
-mod relation_names;
+mod relation_field;
 mod scalar_field;
 
 use crate::calculate_datamodel::{InputContext, OutputContext};
@@ -21,12 +18,7 @@ pub(crate) fn introspect<'a>(
     models::render(input, output);
 
     if input.foreign_keys_enabled() {
-        let relation_names = relation_names::introspect(input);
-
-        inline_relations::render(&relation_names, input, output);
-        m2m_relations::render(&relation_names, input, output);
-    } else {
-        prisma_relation_mode::render(input, output);
+        m2m_relations::render(input, output);
     }
 
     let rendered = if input.render_config {

introspection-engine/connectors/sql-introspection-connector/src/introspection/m2m_relations.rs

@@ -1,12 +1,11 @@
-use super::relation_names::RelationNames;
 use crate::{
     calculate_datamodel::{InputContext, OutputContext},
     introspection_helpers as helpers,
 };
 use sql_schema_describer as sql;
 use std::borrow::Cow;
 
-pub(super) fn render<'a>(relation_names: &RelationNames<'a>, input: InputContext<'a>, output: &mut OutputContext<'a>) {
+pub(super) fn render<'a>(input: InputContext<'a>, output: &mut OutputContext<'a>) {
     for table in input
         .schema
         .table_walkers()
@@ -33,14 +32,14 @@ pub(super) fn render<'a>(relation_names: &RelationNames<'a>, input: InputContext
                     let (field_a, field_b): (Cow<'a, str>, Cow<'a, str>) = if relation.is_self_relation() {
                         // See reasoning in the comment for the
                         // do_not_try_to_keep_custom_many_to_many_relation_names test
-                        let [_, field_a, field_b] = relation_names.m2m_relation_name(table.id).to_owned();
+                        let [_, field_a, field_b] = input.m2m_relation_name(table.id).to_owned();
                         (field_a, field_b)
                     } else {
                         (relation.field_a().name().into(), relation.field_b().name().into())
                     };
                     [name, field_a, field_b]
                 })
-                .unwrap_or_else(|| relation_names.m2m_relation_name(table.id).clone());
+                .unwrap_or_else(|| input.m2m_relation_name(table.id).clone());
 
             calculate_many_to_many_field(fk_a, fk_b, relation_name.clone(), field_a_name, input, output);
             calculate_many_to_many_field(fk_b, fk_a, relation_name, field_b_name, input, output);