feat: put db con behind feature gate

crates/pgt_analyse/Cargo.toml

@@ -16,7 +16,6 @@ version              = "0.0.0"
 pgt_console.workspace      = true
 pgt_diagnostics.workspace  = true
 pgt_query_ext.workspace    = true
-pgt_schema_cache.workspace = true
 rustc-hash                 = { workspace = true }
 
 biome_deserialize        = { workspace = true, optional = true }

crates/pgt_cli/Cargo.toml

@@ -28,7 +28,7 @@ pgt_flags                = { workspace = true }
 pgt_fs                   = { workspace = true }
 pgt_lsp                  = { workspace = true }
 pgt_text_edit            = { workspace = true }
-pgt_workspace            = { workspace = true }
+pgt_workspace            = { workspace = true, features = ["db-connection"] }
 quick-junit              = "0.5.0"
 rayon                    = { workspace = true }
 rustc-hash               = { workspace = true }

crates/pgt_completions/Cargo.toml

@@ -10,30 +10,18 @@ name                 = "pgt_completions"
 repository.workspace = true
 version              = "0.0.0"
 
-
 [dependencies]
 async-std = "1.12.0"
 
-pgt_text_size.workspace = true
-
-
 pgt_schema_cache.workspace       = true
+pgt_text_size.workspace          = true
 pgt_treesitter_queries.workspace = true
-schemars                         = { workspace = true, optional = true }
-serde                            = { workspace = true, features = ["derive"] }
-serde_json                       = { workspace = true }
 tree-sitter.workspace            = true
 tree_sitter_sql.workspace        = true
 
-sqlx.workspace = true
-
-tokio = { version = "1.41.1", features = ["full"] }
-
 [dev-dependencies]
 pgt_test_utils.workspace = true
+tokio                    = { version = "1.41.1", features = ["full"] }
 
 [lib]
 doctest = false
-
-[features]
-schema = ["dep:schemars"]

crates/pgt_completions/src/complete.rs

@@ -1,5 +1,4 @@
 use pgt_text_size::TextSize;
-use serde::{Deserialize, Serialize};
 
 use crate::{
     builder::CompletionBuilder,
@@ -18,10 +17,9 @@ pub struct CompletionParams<'a> {
     pub tree: Option<&'a tree_sitter::Tree>,
 }
 
-#[derive(Debug, Default, Serialize, Deserialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(Debug, Default)]
 pub struct CompletionResult {
-    pub(crate) items: Vec<CompletionItem>,
+    pub items: Vec<CompletionItem>,
 }
 
 impl IntoIterator for CompletionResult {

crates/pgt_completions/src/item.rs

@@ -1,19 +1,14 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[serde(rename_all = "camelCase")]
+#[derive(Debug, PartialEq, Eq)]
 pub enum CompletionItemKind {
     Table,
     Function,
     Column,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(Debug)]
 pub struct CompletionItem {
     pub label: String,
-    pub(crate) score: i32,
+    pub score: i32,
     pub description: String,
     pub preselected: bool,
     pub kind: CompletionItemKind,

crates/pgt_lsp/Cargo.toml

@@ -24,7 +24,7 @@ pgt_fs                  = { workspace = true }
 pgt_lsp_converters      = { workspace = true }
 pgt_text_edit           = { workspace = true }
 pgt_text_size.workspace = true
-pgt_workspace           = { workspace = true }
+pgt_workspace           = { workspace = true, features = ["db-connection"] }
 rustc-hash              = { workspace = true }
 serde                   = { workspace = true, features = ["derive"] }
 serde_json              = { workspace = true }

crates/pgt_lsp/src/handlers/completions.rs

@@ -62,11 +62,15 @@ pub fn get_completions(
 }
 
 fn to_lsp_types_completion_item_kind(
-    pg_comp_kind: pgt_completions::CompletionItemKind,
+    pg_comp_kind: pgt_workspace::workspace::CompletionItemKind,
 ) -> lsp_types::CompletionItemKind {
     match pg_comp_kind {
-        pgt_completions::CompletionItemKind::Function => lsp_types::CompletionItemKind::FUNCTION,
-        pgt_completions::CompletionItemKind::Table => lsp_types::CompletionItemKind::CLASS,
-        pgt_completions::CompletionItemKind::Column => lsp_types::CompletionItemKind::FIELD,
+        pgt_workspace::workspace::CompletionItemKind::Function => {
+            lsp_types::CompletionItemKind::FUNCTION
+        }
+        pgt_workspace::workspace::CompletionItemKind::Table => lsp_types::CompletionItemKind::CLASS,
+        pgt_workspace::workspace::CompletionItemKind::Column => {
+            lsp_types::CompletionItemKind::FIELD
+        }
     }
 }

crates/pgt_wasm/Cargo.toml

@@ -0,0 +1,44 @@
+[package]
+authors.workspace    = true
+categories.workspace = true
+description          = "<DESCRIPTION>"
+edition.workspace    = true
+homepage.workspace   = true
+keywords.workspace   = true
+license.workspace    = true
+name                 = "pgt_wasm"
+repository.workspace = true
+version              = "0.0.0"
+
+[dependencies]
+pgt_console      = { workspace = true }
+pgt_diagnostics  = { workspace = true }
+pgt_workspace      = { workspace = true  }
+js-sys             = "0.3.72"
+serde              = { workspace = true }
+serde-wasm-bindgen = "0.6.5"
+wasm-bindgen       = { version = "0.2.95", features = ["serde-serialize"] }
+getrandom         = { version = "0.2.15", features = ["js"] }
+
+# The `console_error_panic_hook` crate provides better debugging of panics by
+# logging them with `console.error`. This is great for development, but requires
+# all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
+# code size when deploying.
+console_error_panic_hook = { version = "0.1.7", optional = true }
+
+[build-dependencies]
+biome_js_factory   = { workspace = true }
+biome_rowan   = { workspace = true }
+biome_js_formatter = { workspace = true }
+pgt_workspace      = { workspace = true, features = ["schema"] }
+quote              = "1.0.14"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[features]
+default           = ["console_error_panic_hook"]
+
+[package.metadata.wasm-pack.profile.profiling]
+wasm-opt = false
+

crates/pgt_wasm/build.rs

@@ -0,0 +1,102 @@
+use std::{env, fs, io, path::PathBuf};
+
+use quote::{format_ident, quote};
+
+use biome_js_factory::syntax::JsFileSource;
+use biome_js_factory::{
+    make,
+    syntax::{AnyJsDeclaration, AnyJsModuleItem, AnyJsStatement},
+};
+use biome_js_formatter::{context::JsFormatOptions, format_node};
+use biome_rowan::AstNode;
+use pgt_workspace::workspace_types::{generate_type, methods, ModuleQueue};
+
+fn main() -> io::Result<()> {
+    let methods = methods();
+
+    let mut items = Vec::new();
+    let mut queue = ModuleQueue::default();
+
+    for method in &methods {
+        generate_type(&mut items, &mut queue, &method.params);
+        generate_type(&mut items, &mut queue, &method.result);
+    }
+
+    let module = make::js_module(
+        make::js_directive_list(None),
+        make::js_module_item_list(items.into_iter().map(|(decl, _)| {
+            AnyJsModuleItem::AnyJsStatement(match decl {
+                AnyJsDeclaration::JsClassDeclaration(decl) => {
+                    AnyJsStatement::JsClassDeclaration(decl)
+                }
+                AnyJsDeclaration::JsFunctionDeclaration(decl) => {
+                    AnyJsStatement::JsFunctionDeclaration(decl)
+                }
+                AnyJsDeclaration::JsVariableDeclaration(decl) => {
+                    AnyJsStatement::JsVariableStatement(make::js_variable_statement(decl).build())
+                }
+                AnyJsDeclaration::TsDeclareFunctionDeclaration(decl) => {
+                    AnyJsStatement::TsDeclareFunctionDeclaration(decl)
+                }
+                AnyJsDeclaration::TsEnumDeclaration(decl) => {
+                    AnyJsStatement::TsEnumDeclaration(decl)
+                }
+                AnyJsDeclaration::TsExternalModuleDeclaration(decl) => {
+                    AnyJsStatement::TsExternalModuleDeclaration(decl)
+                }
+                AnyJsDeclaration::TsGlobalDeclaration(decl) => {
+                    AnyJsStatement::TsGlobalDeclaration(decl)
+                }
+                AnyJsDeclaration::TsImportEqualsDeclaration(decl) => {
+                    AnyJsStatement::TsImportEqualsDeclaration(decl)
+                }
+                AnyJsDeclaration::TsInterfaceDeclaration(decl) => {
+                    AnyJsStatement::TsInterfaceDeclaration(decl)
+                }
+                AnyJsDeclaration::TsModuleDeclaration(decl) => {
+                    AnyJsStatement::TsModuleDeclaration(decl)
+                }
+                AnyJsDeclaration::TsTypeAliasDeclaration(decl) => {
+                    AnyJsStatement::TsTypeAliasDeclaration(decl)
+                }
+            })
+        })),
+        make::eof(),
+    )
+    .build();
+
+    // Wasm-bindgen will paste the generated TS code as-is into the final .d.ts file,
+    // ensure it looks good by running it through the formatter
+    let formatted = format_node(JsFormatOptions::new(JsFileSource::ts()), module.syntax()).unwrap();
+    let printed = formatted.print().unwrap();
+    let definitions = printed.into_code();
+
+    // Generate wasm-bindgen extern type imports for all the types defined in the TS code
+    let types = queue.visited().iter().map(|name| {
+        let ident = format_ident!("I{name}");
+        quote! {
+            #[wasm_bindgen(typescript_type = #name)]
+            #[allow(non_camel_case_types)]
+            pub type #ident;
+        }
+    });
+
+    let tokens = quote! {
+        #[wasm_bindgen(typescript_custom_section)]
+        const TS_TYPEDEFS: &'static str = #definitions;
+
+        #[wasm_bindgen]
+        extern "C" {
+            #( #types )*
+        }
+    };
+
+    let out_dir = env::var("OUT_DIR").unwrap();
+    fs::write(
+        PathBuf::from(out_dir).join("ts_types.rs"),
+        tokens.to_string(),
+    )?;
+
+    Ok(())
+}
+