fix: allow missing config datasource URL

Author: jacek-prisma

schema-engine/cli/src/commands.rs

@@ -38,28 +38,28 @@ impl Cli {
     ) -> Result<String, ConnectorError> {
         let mut api = schema_core::schema_api(None, datasource_urls.clone(), None, extensions)?;
 
+        let url = datasource_urls
+            .url
+            .ok_or_else(|| ConnectorError::from_msg("No URL defined in the configured datasource".to_owned()))?;
+
         let work = async {
             match self.command {
                 CliCommand::CreateDatabase => api
                     .create_database(schema_core::json_rpc::types::CreateDatabaseParams {
-                        datasource: DatasourceParam::ConnectionString(UrlContainer {
-                            url: datasource_urls.url.clone(),
-                        }),
+                        datasource: DatasourceParam::ConnectionString(UrlContainer { url }),
                     })
                     .await
                     .map(|schema_core::json_rpc::types::CreateDatabaseResult { database_name }| {
                         format!("Database '{database_name}' was successfully created.")
                     }),
                 CliCommand::CanConnectToDatabase => api
                     .ensure_connection_validity(schema_core::json_rpc::types::EnsureConnectionValidityParams {
-                        datasource: DatasourceParam::ConnectionString(UrlContainer {
-                            url: datasource_urls.url.clone(),
-                        }),
+                        datasource: DatasourceParam::ConnectionString(UrlContainer { url }),
                     })
                     .await
                     .map(|_| "Connection successful".to_owned()),
                 CliCommand::DropDatabase => api
-                    .drop_database(datasource_urls.url.clone())
+                    .drop_database(url)
                     .await
                     .map(|_| "The database was successfully dropped.".to_owned()),
             }

schema-engine/core/src/commands/diff_cli.rs

@@ -137,7 +137,10 @@ async fn json_rpc_diff_target_to_dialect(
     extension_types: &dyn ExtensionTypes,
 ) -> CoreResult<Option<(Box<dyn SchemaDialect>, DatabaseSchema)>> {
     let datasource_urls = if let Some(shadow_database_url) = shadow_database_url {
-        &DatasourceUrls::from_url_and_shadow_database_url(&datasource_urls.url, shadow_database_url)
+        &DatasourceUrls {
+            url: datasource_urls.url.clone(),
+            shadow_database_url: Some(shadow_database_url.to_owned()),
+        }
     } else {
         datasource_urls
     };
@@ -170,7 +173,7 @@ async fn json_rpc_diff_target_to_dialect(
                     connector.schema_dialect(),
                 ),
                 Err(_) => {
-                    let dialect = crate::schema_to_dialect(&sources, datasource_urls)?;
+                    let dialect = crate::schema_to_dialect(&sources)?;
                     (dialect.default_namespace().map(|ns| ns.to_string()), dialect)
                 }
             };

schema-engine/core/src/lib.rs

@@ -27,6 +27,7 @@ pub use extensions::{ExtensionType, ExtensionTypeConfig};
 use json_rpc::types::{SchemaContainer, SchemasContainer, SchemasWithConfigDir};
 pub use schema_connector;
 
+use ::commands::dialect_for_provider;
 use enumflags2::BitFlags;
 use mongodb_schema_connector::MongoDbSchemaConnector;
 use psl::{
@@ -89,32 +90,18 @@ fn connector_for_connection_string(
 }
 
 /// Same as schema_to_connector, but it will only read the provider, not the connector params.
-/// This uses `schema_files` to read `preview_features` and the `datasource` block.
-fn schema_to_dialect(
-    schema_files: &[(String, SourceFile)],
-    datasource_urls: &DatasourceUrls,
-) -> CoreResult<Box<dyn schema_connector::SchemaDialect>> {
+/// This uses `schema_files` to read the `datasource` block.
+fn schema_to_dialect(schema_files: &[(String, SourceFile)]) -> CoreResult<Box<dyn schema_connector::SchemaDialect>> {
     let (_, config) = psl::parse_configuration_multi_file(schema_files)
         .map_err(|(files, err)| CoreError::new_schema_parser_error(files.render_diagnostics(&err)))?;
 
-    let preview_features = config.preview_features();
     let datasource = config
         .datasources
         .into_iter()
         .next()
         .ok_or_else(|| CoreError::from_msg("There is no datasource in the schema.".into()))?;
 
-    let datasource_urls = datasource_urls.validate(datasource.active_connector)?;
-
-    let connector_params = ConnectorParams {
-        connection_string: datasource_urls.url().to_owned(),
-        preview_features,
-        shadow_database_connection_string: datasource_urls.shadow_database_url().map(<_>::to_owned),
-    };
-
-    let conn = connector_for_provider(datasource.active_provider, connector_params)?;
-
-    Ok(conn.schema_dialect())
+    dialect_for_provider(datasource.active_provider)
 }
 
 /// Go from a schema to a connector.
@@ -128,14 +115,20 @@ fn schema_to_connector(
 
     let (connection_string, shadow_database_connection_string) = if let Some(config_dir) = config_dir {
         let urls = datasource_urls.with_config_dir(datasource.active_connector.flavour(), config_dir);
-        (urls.url().to_owned(), urls.shadow_database_url().map(<_>::to_owned))
+        (
+            urls.url().map(<_>::to_owned),
+            urls.shadow_database_url().map(<_>::to_owned),
+        )
     } else {
         (
-            datasource_urls.url().to_owned(),
+            datasource_urls.url().map(<_>::to_owned),
             datasource_urls.shadow_database_url().map(<_>::to_owned),
         )
     };
 
+    let connection_string = connection_string
+        .ok_or_else(|| CoreError::from_msg("No URL defined in the configured datasource".to_owned()))?;
+
     let params = ConnectorParams {
         connection_string,
         preview_features,
@@ -153,7 +146,10 @@ fn initial_datamodel_to_connector(
     let (datasource, preview_features) = extract_configuration_ref(configuration)?;
 
     let params = ConnectorParams {
-        connection_string: datasource_urls.url().to_owned(),
+        connection_string: datasource_urls
+            .url()
+            .ok_or_else(|| CoreError::from_msg("No URL defined in the configured datasource".to_owned()))?
+            .to_owned(),
         preview_features,
         shadow_database_connection_string: datasource_urls.shadow_database_url().map(<_>::to_owned),
     };

schema-engine/core/src/state.rs

@@ -218,6 +218,7 @@ impl EngineState {
         Ok(self
             .validate_datasource_urls(&datasource)?
             .url_with_config_dir(datasource.active_connector.flavour(), Path::new(&container.config_dir))
+            .ok_or_else(|| CoreError::from_msg("No URL defined in the configured datasource".to_owned()))?
             .into_owned())
     }
 

schema-engine/core/src/url.rs

@@ -12,15 +12,15 @@ use crate::core_error::CoreError;
 #[serde(rename_all = "camelCase")]
 pub struct DatasourceUrls {
     /// Direct URL to the database.
-    pub url: String,
+    pub url: Option<String>,
     /// The URL to a live shadow database, if Prisma should use it instead of creating one.
     pub shadow_database_url: Option<String>,
 }
 
 /// Datasource URLs that have passed validation and are safe to consume by the schema engine.
 #[derive(Debug, Clone)]
 pub struct ValidatedDatasourceUrls {
-    url: String,
+    url: Option<String>,
     shadow_database_url: Option<String>,
 }
 
@@ -43,15 +43,15 @@ impl DatasourceUrls {
     /// Creates a `DatasourceUrls` instance containing only a primary URL.
     pub fn from_url(url: impl Into<String>) -> Self {
         Self {
-            url: url.into(),
+            url: Some(url.into()),
             shadow_database_url: None,
         }
     }
 
     /// Creates a `DatasourceUrls` instance with both primary and shadow database URLs.
     pub fn from_url_and_shadow_database_url(url: impl Into<String>, shadow_database_url: impl Into<String>) -> Self {
         Self {
-            url: url.into(),
+            url: Some(url.into()),
             shadow_database_url: Some(shadow_database_url.into()),
         }
     }
@@ -61,7 +61,9 @@ impl DatasourceUrls {
         &self,
         connector: &dyn psl::datamodel_connector::Connector,
     ) -> Result<ValidatedDatasourceUrls, DatasourceError> {
-        validate_datasource_url(&self.url, connector, "url")?;
+        if let Some(url) = &self.url {
+            validate_datasource_url(url, connector, "url")?;
+        }
 
         if let Some(shadow_database_url) = &self.shadow_database_url {
             validate_datasource_url(shadow_database_url, connector, "shadowDatabaseUrl")?;
@@ -115,8 +117,8 @@ impl From<DatasourceError> for CoreError {
 
 impl ValidatedDatasourceUrls {
     /// Returns the validated primary datasource URL.
-    pub fn url(&self) -> &str {
-        &self.url
+    pub fn url(&self) -> Option<&str> {
+        self.url.as_deref()
     }
 
     /// Returns the validated shadow database URL, if any.
@@ -125,14 +127,14 @@ impl ValidatedDatasourceUrls {
     }
 
     /// Resolves relative paths in the URL against the provided configuration directory.
-    pub fn url_with_config_dir(&self, flavour: Flavour, config_dir: &Path) -> Cow<'_, str> {
-        set_config_dir(flavour, config_dir, &self.url)
+    pub fn url_with_config_dir(&self, flavour: Flavour, config_dir: &Path) -> Option<Cow<'_, str>> {
+        self.url.as_deref().map(|url| set_config_dir(flavour, config_dir, url))
     }
 
     /// Returns both URLs with relative file paths rewritten relative to the configuration directory.
     pub fn with_config_dir(&self, flavour: Flavour, config_dir: &Path) -> DatasourceUrlsWithConfigDir<'_> {
         DatasourceUrlsWithConfigDir {
-            url: set_config_dir(flavour, config_dir, &self.url),
+            url: self.url_with_config_dir(flavour, config_dir),
             shadow_database_url: self
                 .shadow_database_url
                 .as_deref()
@@ -144,14 +146,14 @@ impl ValidatedDatasourceUrls {
 /// Datasource URLs with relative paths resolved against the configuration directory.
 #[derive(Debug, Clone)]
 pub struct DatasourceUrlsWithConfigDir<'a> {
-    url: Cow<'a, str>,
+    url: Option<Cow<'a, str>>,
     shadow_database_url: Option<Cow<'a, str>>,
 }
 
 impl DatasourceUrlsWithConfigDir<'_> {
     /// Returns the primary datasource URL, with resolved paths if needed.
-    pub fn url(&self) -> &str {
-        &self.url
+    pub fn url(&self) -> Option<&str> {
+        self.url.as_deref()
     }
 
     /// Returns the shadow database URL, with resolved paths if present.

schema-engine/sql-migration-tests/src/test_api.rs

@@ -206,7 +206,7 @@ impl TestApi {
     pub fn diff(&self, params: DiffParams) -> ConnectorResult<DiffResult> {
         self.diff_with_datasource(
             &DatasourceUrls {
-                url: self.connection_string().to_owned(),
+                url: Some(self.connection_string().to_owned()),
                 shadow_database_url: self.shadow_database_connection_string().map(<_>::to_owned),
             },
             params,

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

@@ -424,7 +424,7 @@ fn from_empty_to_migrations_folder_without_shadow_db_url_must_error(mut api: Tes
     let err = api
         .diff_with_datasource(
             &DatasourceUrls {
-                url: api.connection_string().to_owned(),
+                url: Some(api.connection_string().to_owned()),
                 shadow_database_url: None,
             },
             params,

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

@@ -17,7 +17,7 @@ impl TestApi {
             api: RpcApi::new(
                 None,
                 DatasourceUrls {
-                    url: args.database_url().to_owned(),
+                    url: Some(args.database_url().to_owned()),
                     shadow_database_url: args.shadow_database_url().map(ToOwned::to_owned),
                 },
                 host,