feat: geospatial types support

.github/workflows/test-query-engine-template.yml

@@ -71,6 +71,10 @@ jobs:
       - name: "Start ${{ inputs.name }} (${{ matrix.engine_protocol }})"
         run: make start-${{ inputs.name }}
 
+      - name: Install Spatialite
+        if: ${{ inputs.name == 'spatialite' }}
+        run: sudo apt install -y libsqlite3-mod-spatialite && echo "SPATIALITE_PATH=mod_spatialite" >> $GITHUB_ENV
+
       - run: export WORKSPACE_ROOT=$(pwd) && cargo nextest run -p query-engine-tests --partition hash:${{ matrix.partition }} --test-threads=1
         if: ${{ inputs.single_threaded }}
         env:

.github/workflows/test-query-engine.yml

@@ -40,6 +40,8 @@ jobs:
             version: "10"
           - name: "postgres9"
             version: "9"
+          - name: 'postgis16'
+            version: '16-postgis'
     uses: ./.github/workflows/test-query-engine-template.yml
     name: postgres ${{ matrix.database.version }}
     with:
@@ -81,7 +83,6 @@ jobs:
       matrix:
         database:
           - name: "cockroach_23_1"
-            connector: "cockroachdb"
             version: "23.1"
           - name: "cockroach_22_2"
             version: "22.2"
@@ -137,11 +138,19 @@ jobs:
       relation_load_strategy: '["query"]'
 
   sqlite:
+    strategy:
+      fail-fast: false
+      matrix:
+        database:
+          - name: "sqlite"
+            version: "3"
+          - name: "spatialite"
+            version: "3-spatialite"
     uses: ./.github/workflows/test-query-engine-template.yml
-    name: sqlite
+    name: sqlite ${{ matrix.database.version }}
     with:
-      name: "sqlite"
-      version: 3
+      name: ${{ matrix.database.name }}
+      version: ${{ matrix.database.version }}
       connector: "sqlite"
       relation_load_strategy: '["query"]'
 

.github/workflows/test-schema-engine.yml

@@ -91,6 +91,8 @@ jobs:
             url: "postgresql://postgres:prisma@localhost:5438"
           - name: postgres16
             url: "postgresql://postgres:prisma@localhost:5439"
+          - name: postgis16
+            url: 'postgresql://postgres:prisma@localhost:5440'
           - name: cockroach_23_1
             url: "postgresql://prisma@localhost:26260"
           - name: cockroach_22_2
@@ -99,6 +101,8 @@ jobs:
             url: "postgresql://prisma@localhost:26257"
           - name: sqlite
             url: sqlite
+          - name: spatialite
+            url: sqlite
           - name: vitess_8_0
             url: "mysql://root:prisma@localhost:33807/test"
             shadow_database_url: "mysql://root:prisma@localhost:33808/shadow"
@@ -124,6 +128,10 @@ jobs:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
+      - name: Install Spatialite
+        if: ${{ matrix.database.name == 'spatialite' }}
+        run: sudo apt install -y libsqlite3-mod-spatialite && echo "SPATIALITE_PATH=mod_spatialite" >> $GITHUB_ENV
+
       - name: "Start ${{ matrix.database.name }}"
         run: make start-${{ matrix.database.name }}
 

.test_database_urls/postgis_16

@@ -0,0 +1 @@
+export TEST_DATABASE_URL="postgresql://postgres:prisma@localhost:5440"

Makefile

@@ -136,6 +136,11 @@ start-sqlite:
 dev-sqlite:
 	cp $(CONFIG_PATH)/sqlite $(CONFIG_FILE)
 
+start-spatialite:
+
+dev-spatialite:
+	cp $(CONFIG_PATH)/spatialite $(CONFIG_FILE)
+
 dev-react-native:
 	cp $(CONFIG_PATH)/react-native $(CONFIG_FILE)
 
@@ -248,6 +253,12 @@ start-postgres16:
 dev-postgres16: start-postgres16
 	cp $(CONFIG_PATH)/postgres16 $(CONFIG_FILE)
 
+start-postgis16:
+	docker compose -f docker-compose.yml up -d --remove-orphans postgis16
+
+dev-postgis16: start-postgis16
+	cp $(CONFIG_PATH)/postgis16 $(CONFIG_FILE)
+
 start-cockroach_23_1:
 	docker compose -f docker-compose.yml up --wait -d --remove-orphans cockroach_23_1
 

docker-compose.yml

@@ -226,6 +226,19 @@ services:
     networks:
       - databases
 
+  postgis16:
+    image: postgis/postgis:16-3.4
+    restart: unless-stopped
+    command: postgres -c 'max_connections=1000'
+    environment:
+      POSTGRES_PASSWORD: "prisma"
+      POSTGRES_HOST_AUTH_METHOD: "md5"
+      POSTGRES_INITDB_ARGS: "--auth-host=md5"
+    ports:
+      - "5440:5432"
+    networks:
+      - databases
+
   mysql-5-6:
     image: mysql:5.6.50
     command: mysqld --table_definition_cache=2000

libs/prisma-value/src/lib.rs

@@ -28,6 +28,8 @@ pub enum PrismaValue {
     Uuid(Uuid),
     List(PrismaListValue),
     Json(String),
+    GeoJson(String),
+    Geometry(String),
 
     /// A collections of key-value pairs constituting an object.
     #[serde(serialize_with = "serialize_object")]
@@ -330,6 +332,8 @@ impl fmt::Display for PrismaValue {
             PrismaValue::Null => "null".fmt(f),
             PrismaValue::Uuid(x) => x.fmt(f),
             PrismaValue::Json(x) => x.fmt(f),
+            PrismaValue::GeoJson(x) => x.fmt(f),
+            PrismaValue::Geometry(x) => x.fmt(f),
             PrismaValue::BigInt(x) => x.fmt(f),
             PrismaValue::List(x) => {
                 let as_string = format!("{x:?}");

libs/test-setup/src/postgres.rs

@@ -7,9 +7,14 @@ pub(crate) fn get_postgres_tags(database_url: &str) -> Result<BitFlags<Tags>, St
     let fut = async {
         let quaint = Quaint::new(database_url).await.map_err(|err| err.to_string())?;
         let mut tags = Tags::Postgres.into();
-        let version = quaint.version().await.map_err(|err| err.to_string())?;
 
-        match version {
+        if let Ok(_postgis_version) = quaint.query_raw("SELECT PostGIS_version()", &[]).await {
+            tags |= Tags::PostGIS;
+        }
+
+        let postgres_version = quaint.version().await.map_err(|err| err.to_string())?;
+
+        match postgres_version {
             None => Ok(tags),
             Some(version) => {
                 eprintln!("version: {version:?}");

libs/test-setup/src/sqlite.rs

@@ -1,4 +1,8 @@
+use enumflags2::BitFlags;
 use once_cell::sync::Lazy;
+use quaint::{prelude::Queryable, single::Quaint};
+
+use crate::{runtime::run_with_thread_local_runtime as tok, Tags};
 
 pub fn sqlite_test_url(db_name: &str) -> String {
     std::env::var("SQLITE_TEST_URL").unwrap_or_else(|_| format!("file:{}", sqlite_test_file(db_name)))
@@ -25,3 +29,17 @@ fn sqlite_test_file(db_name: &str) -> String {
 
     file_path.to_string_lossy().into_owned()
 }
+
+pub(crate) fn get_sqlite_tags() -> Result<BitFlags<Tags>, String> {
+    let fut = async {
+        let mut tags: BitFlags<Tags> = Tags::Sqlite.into();
+        // The SpatiaLite extension is loaded by quaint, assuming the SPATIALITE_PATH env variable is set
+        // If the extension can be loaded in a dummy database, it means it will also be available for the tests
+        let quaint = Quaint::new_in_memory().map_err(|err| err.to_string())?;
+        if let Ok(_has_spatialite) = quaint.query_raw("SELECT spatialite_version();", &[]).await {
+            tags |= Tags::Spatialite;
+        }
+        Ok(tags)
+    };
+    tok(fut)
+}

libs/test-setup/src/tags.rs

@@ -42,6 +42,8 @@ tags![
     CockroachDb222 = 1 << 20,
     CockroachDb231 = 1 << 21,
     Postgres16 = 1 << 22,
+    PostGIS = 1 << 23,
+    Spatialite = 1 << 24,
 ];
 
 pub fn tags_from_comma_separated_list(input: &str) -> BitFlags<Tags> {

libs/test-setup/src/test_api_args.rs

@@ -1,4 +1,4 @@
-use crate::{logging, mssql, mysql, postgres, Capabilities, Tags};
+use crate::{logging, mssql, mysql, postgres, sqlite, Capabilities, Tags};
 use enumflags2::BitFlags;
 use once_cell::sync::Lazy;
 use quaint::single::Quaint;
@@ -41,7 +41,7 @@ static DB_UNDER_TEST: Lazy<Result<DbUnderTest, String>> = Lazy::new(|| {
     match prefix {
         "file" | "sqlite" => Ok(DbUnderTest {
             database_url,
-            tags: Tags::Sqlite.into(),
+            tags: sqlite::get_sqlite_tags()?,
             capabilities: Capabilities::CreateDatabase.into(),
             provider: "sqlite",
             shadow_database_url,

libs/user-facing-errors/src/lib.rs

@@ -121,7 +121,7 @@ impl Error {
 
     /// Construct a new UnknownError from a `PanicInfo` in a panic hook. `UnknownError`s created
     /// with this constructor will have a proper, useful backtrace.
-    pub fn new_in_panic_hook(panic_info: &std::panic::PanicInfo<'_>) -> Self {
+    pub fn new_in_panic_hook(panic_info: &std::panic::PanicHookInfo<'_>) -> Self {
         let message = panic_info
             .payload()
             .downcast_ref::<&str>()

libs/user-facing-errors/src/schema_engine.rs

@@ -24,6 +24,7 @@ pub struct DestructiveMigrationDetected {
     code = "P3002",
     message = "The attempted migration was rolled back: {database_error}"
 )]
+#[allow(dead_code)]
 struct MigrationRollback {
     pub database_error: String,
 }

prisma-fmt/src/lib.rs

@@ -205,6 +205,7 @@ pub fn validate(validate_params: String) -> Result<(), String> {
 }
 
 /// Given a list of Prisma schema files (and their locations), returns the merged schema.
+///
 /// This is useful for `@prisma/client` generation, where the client needs a single - potentially large - schema,
 /// while still allowing the user to split their schema copies into multiple files.
 /// Internally, it uses `[validate]`.