fix: allow missing config datasource URL

jacek-prisma · jacek-prisma · commit 9b1823b2da73 · 2026-02-18T14:23:54.000Z
diff --git a/schema-engine/cli/src/commands.rs b/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()),
             }
diff --git a/schema-engine/cli/tests/cli_tests.rs b/schema-engine/cli/tests/cli_tests.rs
@@ -938,3 +938,27 @@ fn get_database_version_multi_file(_api: TestApi) {
         }
     });
 }
+
+#[tokio::test]
+async fn test_missing_datasource_url_gives_proper_error() {
+    let datasource_urls = DatasourceUrls {
+        url: None,
+        shadow_database_url: None,
+    };
+
+    let output = Command::new(schema_engine_bin_path())
+        .arg("--datasource")
+        .arg(serde_json::to_string(&datasource_urls).unwrap())
+        .arg("cli")
+        .arg("can-connect-to-database")
+        .output()
+        .unwrap();
+
+    assert_eq!(output.status.code(), Some(1));
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(
+        stderr.contains("No URL defined in the configured datasource"),
+        "Expected error message about missing URL, got: {}",
+        stderr
+    );
+}
diff --git a/schema-engine/core/src/commands/diff_cli.rs b/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)
                 }
             };
diff --git a/schema-engine/core/src/lib.rs b/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),
     };
diff --git a/schema-engine/core/src/state.rs b/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())
     }
 
diff --git a/schema-engine/core/src/url.rs b/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.
diff --git a/schema-engine/sql-migration-tests/src/test_api.rs b/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,
diff --git a/schema-engine/sql-migration-tests/tests/errors/error_tests.rs b/schema-engine/sql-migration-tests/tests/errors/error_tests.rs
@@ -500,3 +500,95 @@ async fn connection_string_problems_give_a_nice_error() {
         assert_eq!(expected, json_error);
     }
 }
+
+#[tokio::test]
+async fn missing_datasource_url_gives_proper_error() {
+    let dm = r#"
+        datasource db {
+            provider = "postgresql"
+        }
+
+        model User {
+            id Int @id
+        }
+    "#;
+
+    let datasource_urls = DatasourceUrls {
+        url: None,
+        shadow_database_url: None,
+    };
+
+    let mut api = schema_core::schema_api_without_extensions(Some(dm.to_owned()), datasource_urls, None).unwrap();
+
+    let error = api
+        .ensure_connection_validity(EnsureConnectionValidityParams {
+            datasource: DatasourceParam::Schema(SchemasContainer {
+                files: vec![SchemaContainer {
+                    path: "schema.prisma".to_string(),
+                    content: dm.to_string(),
+                }],
+            }),
+        })
+        .await
+        .unwrap_err();
+
+    api.dispose().await.unwrap();
+
+    let json_error = serde_json::to_value(error.to_user_facing()).unwrap();
+    assert!(
+        json_error["message"]
+            .as_str()
+            .unwrap()
+            .contains("No URL defined in the configured datasource"),
+        "Expected error message about missing URL, got: {}",
+        json_error["message"]
+    );
+}
+
+#[tokio::test]
+async fn diff_from_empty_schema_to_datamodel_should_not_require_url() {
+    use schema_core::json_rpc::types::{DiffParams, DiffTarget, SchemaContainer, SchemaFilter, SchemasContainer};
+
+    let dm = r#"
+        datasource db {
+            provider = "postgresql"
+        }
+
+        model User {
+            id Int @id
+            name String
+        }
+    "#;
+
+    let datasource_urls = DatasourceUrls {
+        url: None,
+        shadow_database_url: None,
+    };
+
+    let mut api = schema_core::schema_api_without_extensions(Some(dm.to_owned()), datasource_urls, None).unwrap();
+
+    // This should succeed because we're doing a schema-only diff that doesn't require database connection
+    let result = api
+        .diff(DiffParams {
+            from: DiffTarget::Empty,
+            to: DiffTarget::SchemaDatamodel(SchemasContainer {
+                files: vec![SchemaContainer {
+                    path: "schema.prisma".to_string(),
+                    content: dm.to_string(),
+                }],
+            }),
+            shadow_database_url: None,
+            script: false,
+            exit_code: None,
+            filters: SchemaFilter::default(),
+        })
+        .await;
+
+    api.dispose().await.unwrap();
+
+    assert!(
+        result.is_ok(),
+        "Schema-only diff should not require datasource URL, but got error: {:?}",
+        result
+    );
+}
diff --git a/schema-engine/sql-migration-tests/tests/migrations/diff.rs b/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,
diff --git a/schema-engine/sql-migration-tests/tests/migrations/jsonrpc.rs b/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,

Original file line number	Diff line number	Diff line change
`@@ -218,6 +218,7 @@ impl EngineState {`
`218`	`218`	`Ok(self`
`219`	`219`	`.validate_datasource_urls(&datasource)?`
`220`	`220`	`.url_with_config_dir(datasource.active_connector.flavour(), Path::new(&container.config_dir))`
	`221`	`+ .ok_or_else(\|\| CoreError::from_msg("No URL defined in the configured datasource".to_owned()))?`
`221`	`222`	`.into_owned())`
`222`	`223`	`}`
`223`	`224`