feat: add schema field

Author: psteinroe

crates/pglt_configuration/src/lib.rs

@@ -45,6 +45,11 @@ pub const VERSION: &str = match option_env!("PGLT_VERSION") {
 #[partial(cfg_attr(feature = "schema", derive(schemars::JsonSchema)))]
 #[partial(serde(deny_unknown_fields, rename_all = "camelCase"))]
 pub struct Configuration {
+    /// A field for the [JSON schema](https://json-schema.org/) specification
+    #[partial(serde(rename = "$schema"))]
+    #[partial(bpaf(hide))]
+    pub schema: String,
+
     /// The configuration of the VCS integration
     #[partial(type, bpaf(external(partial_vcs_configuration), optional, hide_usage))]
     pub vcs: VcsConfiguration,
@@ -79,6 +84,10 @@ impl PartialConfiguration {
     /// Returns the initial configuration.
     pub fn init() -> Self {
         Self {
+            // TODO: Update this once we have a static url
+            schema: Some(format!(
+                "https://supabase-community.github.io/postgres_lsp/schemas/{VERSION}/schema.json"
+            )),
             files: Some(PartialFilesConfiguration {
                 ignore: Some(Default::default()),
                 ..Default::default()

crates/pglt_workspace/src/configuration.rs

@@ -7,7 +7,7 @@ use std::{
 use pglt_analyse::AnalyserRules;
 use pglt_configuration::{
     ConfigurationDiagnostic, ConfigurationPathHint, ConfigurationPayload, PartialConfiguration,
-    push_to_analyser_rules,
+    VERSION, push_to_analyser_rules,
 };
 use pglt_fs::{AutoSearchResult, ConfigName, FileSystem, OpenOptions};
 
@@ -97,7 +97,7 @@ fn load_config(
     // we'll load it directly
     if let ConfigurationPathHint::FromUser(ref config_file_path) = base_path {
         if file_system.path_is_file(config_file_path) {
-            let content = file_system.read_file_from_path(config_file_path)?;
+            let content = strip_jsonc_comments(&file_system.read_file_from_path(config_file_path)?);
 
             let deserialized = serde_json::from_str::<PartialConfiguration>(&content)
                 .map_err(ConfigurationDiagnostic::new_deserialization_error)?;
@@ -128,8 +128,9 @@ fn load_config(
     )? {
         let AutoSearchResult { content, file_path } = auto_search_result;
 
-        let deserialized = serde_json::from_str::<PartialConfiguration>(&content)
-            .map_err(ConfigurationDiagnostic::new_deserialization_error)?;
+        let deserialized =
+            serde_json::from_str::<PartialConfiguration>(&strip_jsonc_comments(&content))
+                .map_err(ConfigurationDiagnostic::new_deserialization_error)?;
 
         Ok(Some(ConfigurationPayload {
             deserialized,
@@ -150,7 +151,7 @@ fn load_config(
 /// - the program doesn't have the write rights
 pub fn create_config(
     fs: &mut DynRef<dyn FileSystem>,
-    configuration: PartialConfiguration,
+    configuration: &mut PartialConfiguration,
 ) -> Result<(), WorkspaceError> {
     let path = PathBuf::from(ConfigName::pglt_json());
 
@@ -168,6 +169,19 @@ pub fn create_config(
         }
     })?;
 
+    // we now check if biome is installed inside `node_modules` and if so, we use the schema from there
+    if VERSION == "0.0.0" {
+        let schema_path = Path::new("./node_modules/@pglt/pglt/schema.json");
+        let options = OpenOptions::default().read(true);
+        if fs.open_with_options(schema_path, options).is_ok() {
+            configuration.schema = schema_path.to_str().map(String::from);
+        }
+    } else {
+        configuration.schema = Some(format!(
+            "https://supabase-community.github.io/postgres_lsp/schemas/{VERSION}/schema.json"
+        ));
+    }
+
     let contents = serde_json::to_string_pretty(&configuration)
         .map_err(|_| ConfigurationDiagnostic::new_serialization_error())?;
 
@@ -186,3 +200,68 @@ pub fn to_analyser_rules(settings: &Settings) -> AnalyserRules {
     }
     analyser_rules
 }
+
+/// Takes a string of jsonc content and returns a comment free version
+/// which should parse fine as regular json.
+/// Nested block comments are supported.
+pub fn strip_jsonc_comments(jsonc_input: &str) -> String {
+    let mut json_output = String::new();
+
+    let mut block_comment_depth: u8 = 0;
+    let mut is_in_string: bool = false; // Comments cannot be in strings
+
+    for line in jsonc_input.split('\n') {
+        let mut last_char: Option<char> = None;
+        for cur_char in line.chars() {
+            // Check whether we're in a string
+            if block_comment_depth == 0 && last_char != Some('\\') && cur_char == '"' {
+                is_in_string = !is_in_string;
+            }
+
+            // Check for line comment start
+            if !is_in_string && last_char == Some('/') && cur_char == '/' {
+                last_char = None;
+                json_output.push_str("  ");
+                break; // Stop outputting or parsing this line
+            }
+            // Check for block comment start
+            if !is_in_string && last_char == Some('/') && cur_char == '*' {
+                block_comment_depth += 1;
+                last_char = None;
+                json_output.push_str("  ");
+            // Check for block comment end
+            } else if !is_in_string && last_char == Some('*') && cur_char == '/' {
+                block_comment_depth = block_comment_depth.saturating_sub(1);
+                last_char = None;
+                json_output.push_str("  ");
+            // Output last char if not in any block comment
+            } else {
+                if block_comment_depth == 0 {
+                    if let Some(last_char) = last_char {
+                        json_output.push(last_char);
+                    }
+                } else {
+                    json_output.push_str(" ");
+                }
+                last_char = Some(cur_char);
+            }
+        }
+
+        // Add last char and newline if not in any block comment
+        if let Some(last_char) = last_char {
+            if block_comment_depth == 0 {
+                json_output.push(last_char);
+            } else {
+                json_output.push(' ');
+            }
+        }
+
+        // Remove trailing whitespace from line
+        while json_output.ends_with(' ') {
+            json_output.pop();
+        }
+        json_output.push('\n');
+    }
+
+    json_output
+}