feat: type checkerrrrr create

Author: psteinroe

.github/workflows/ci.yml

@@ -27,6 +27,9 @@ jobs:
         ports:
           - 5432:5432
 
+    env:
+      DB_CONNECTION_STRING: postgresql://postgres:postgres@localhost:5432/postgres
+
     steps:
       - name: 🏗 Setup repository
         uses: actions/checkout@v3
@@ -38,6 +41,9 @@ jobs:
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Run test migrations
+        run: psql -f test-db/seed.sql postgresql://postgres:postgres@localhost:5432/postgres
+
       - name: 📦 Build
         id: build
         run: cargo build

Cargo.lock

@@ -11,7 +11,7 @@ rust-version = "1.71"
 [workspace.dependencies]
 ide = { path = "./crates/ide", version = "0.0.0" }
 diagnostics = { path = "./crates/diagnostics", version = "0.0.0" }
-typecheck = { path = "./crates/typecheck", version = "0.0.0" }
+typecheck_sqlx = { path = "./crates/typecheck_sqlx", version = "0.0.0" }
 lint = { path = "./crates/lint", version = "0.0.0" }
 hover = { path = "./crates/hover", version = "0.0.0" }
 base_db = { path = "./crates/base_db", version = "0.0.0" }

Cargo.toml

@@ -9,6 +9,7 @@ dashmap = "5.5.3"
 base_db.workspace =  true
 lint.workspace =  true
 hover.workspace =  true
+sqlx = { version = "0.7.3", features = [ "runtime-async-std", "tls-rustls", "postgres", "json" ] }
 sql_parser.workspace = true
 diagnostics.workspace = true
 tree-sitter.workspace = true

crates/ide/Cargo.toml

@@ -9,6 +9,7 @@ use dashmap::{DashMap, DashSet};
 use lint::Linter;
 use pg_query::PgQueryParser;
 use schema_cache::SchemaCache;
+use sqlx::PgPool;
 use tracing::{event, span, Level};
 use tree_sitter::TreeSitterParser;
 
@@ -107,7 +108,7 @@ impl IDE {
     }
 
     /// Drain changed statements to kick off analysis
-    pub fn compute(&self) {
+    pub fn compute(&self, conn: Option<PgPool>) {
         let changed: Vec<StatementRef> = self
             .changed_stmts
             .iter()

crates/ide/src/lib.rs

@@ -290,11 +290,13 @@ impl Server {
 
         let ide = Arc::clone(&self.ide);
         let tx = self.internal_tx.clone();
+        let conn = self.db_conn.as_ref().map(|p| p.pool.clone());
+
         self.pool.execute(move || {
             // TODO this should happen on change too but once at a time after some debounced delay
             // also on open
             // check chatgpt for sample for debouncer
-            ide.compute();
+            ide.compute(conn);
             tx.send(InternalMessage::PublishDiagnostics(cloned_uri));
         });
 

crates/lsp/src/server.rs

@@ -1,12 +1,16 @@
 [package]
-name = "typecheck"
+name = "typecheck_sqlx"
 version = "0.0.0"
 edition = "2021"
 
 [dependencies]
 base_db.workspace = true
 schema_cache.workspace = true
+text-size = "1.1.1"
+sql_parser.workspace = true
+async-std = "1.12.0"
 tracing.workspace = true
+sqlx = { version = "0.7.3", features = [ "runtime-async-std", "tls-rustls", "postgres", "json" ] }
 
 [dev-dependencies]
 

crates/typecheck/src/lib.rs

@@ -0,0 +1,103 @@
+use sqlx::postgres::PgDatabaseError;
+use sqlx::postgres::PgSeverity;
+use sqlx::Executor;
+use sqlx::PgPool;
+use text_size::TextRange;
+use text_size::TextSize;
+
+pub struct TypecheckerParams<'a> {
+    pub conn: &'a PgPool,
+    pub sql: &'a str,
+    pub enriched_ast: Option<&'a sql_parser::EnrichedAst>,
+}
+
+#[derive(Debug, Clone)]
+pub struct TypeError {
+    pub message: String,
+    pub code: String,
+    pub severity: PgSeverity,
+    pub position: Option<usize>,
+    pub range: Option<TextRange>,
+    pub table: Option<String>,
+    pub column: Option<String>,
+    pub data_type: Option<String>,
+    pub constraint: Option<String>,
+}
+
+pub async fn check_sql<'a>(params: TypecheckerParams<'a>) -> Vec<TypeError> {
+    let mut errs = vec![];
+
+    let res = params.conn.prepare(params.sql).await;
+
+    if res.is_err() {
+        if let sqlx::Error::Database(err) = res.as_ref().unwrap_err() {
+            let pg_err = err.downcast_ref::<PgDatabaseError>();
+
+            let position = match pg_err.position() {
+                Some(sqlx::postgres::PgErrorPosition::Original(pos)) => Some(pos - 1),
+                _ => None,
+            };
+
+            let range = match params.enriched_ast {
+                Some(ast) => {
+                    if position.is_none() {
+                        None
+                    } else {
+                        ast.covering_node(TextRange::empty(
+                            TextSize::try_from(position.unwrap()).unwrap(),
+                        ))
+                        .map(|node| node.range())
+                    }
+                }
+                None => None,
+            };
+
+            errs.push(TypeError {
+                message: pg_err.message().to_string(),
+                code: pg_err.code().to_string(),
+                severity: pg_err.severity(),
+                position,
+                range,
+                table: pg_err.table().map(|s| s.to_string()),
+                column: pg_err.column().map(|s| s.to_string()),
+                data_type: pg_err.data_type().map(|s| s.to_string()),
+                constraint: pg_err.constraint().map(|s| s.to_string()),
+            });
+        }
+    }
+
+    errs
+}
+
+#[cfg(test)]
+mod tests {
+    use async_std::task::block_on;
+    use sql_parser::parse_ast;
+    use sqlx::PgPool;
+
+    use crate::{check_sql, TypecheckerParams};
+
+    #[test]
+    fn test_check_sql() {
+        let input = "select id, unknown from contact;";
+
+        let conn_string = std::env::var("DB_CONNECTION_STRING").unwrap();
+
+        let pool = block_on(PgPool::connect(conn_string.as_str())).unwrap();
+
+        let root = sql_parser::parse_sql_statement(input).unwrap();
+        let ast = parse_ast(input, &root).ast;
+
+        let errs = block_on(check_sql(TypecheckerParams {
+            conn: &pool,
+            sql: input,
+            enriched_ast: Some(&ast),
+        }));
+
+        assert_eq!(errs.len(), 1);
+
+        let e = &errs[0];
+
+        assert_eq!(&input[e.range.unwrap()], "unknown");
+    }
+}

crates/typecheck/Cargo.toml crates/typecheck_sqlx/Cargo.toml

@@ -0,0 +1,6 @@
+create table public.contact (
+    id serial primary key not null,
+    created_at timestamp with time zone not null default now(),
+    username text
+);
+