squawk-cli 2.37.0__tar.gz → 2.39.0__tar.gz

{squawk_cli-2.37.0 → squawk_cli-2.39.0}/Cargo.lock

@@ -1882,7 +1882,7 @@ dependencies = [
 
 [[package]]
 name = "squawk"
-version = "2.37.0"
+version = "2.39.0"
 dependencies = [
  "annotate-snippets",
  "anyhow",
@@ -1909,9 +1909,19 @@ dependencies = [
  "toml",
 ]
 
+[[package]]
+name = "squawk-fmt"
+version = "2.39.0"
+dependencies = [
+ "insta",
+ "itertools 0.14.0",
+ "squawk-syntax",
+ "tiny_pretty",
+]
+
 [[package]]
 name = "squawk-github"
-version = "2.37.0"
+version = "2.39.0"
 dependencies = [
  "jsonwebtoken",
  "log",
@@ -1922,7 +1932,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-ide"
-version = "2.37.0"
+version = "2.39.0"
 dependencies = [
  "annotate-snippets",
  "insta",
@@ -1940,14 +1950,14 @@ dependencies = [
 
 [[package]]
 name = "squawk-lexer"
-version = "2.37.0"
+version = "2.39.0"
 dependencies = [
  "insta",
 ]
 
 [[package]]
 name = "squawk-linter"
-version = "2.37.0"
+version = "2.39.0"
 dependencies = [
  "annotate-snippets",
  "enum-iterator",
@@ -1962,7 +1972,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-parser"
-version = "2.37.0"
+version = "2.39.0"
 dependencies = [
  "annotate-snippets",
  "camino",
@@ -1976,7 +1986,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-server"
-version = "2.37.0"
+version = "2.39.0"
 dependencies = [
  "anyhow",
  "insta",
@@ -1996,7 +2006,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-syntax"
-version = "2.37.0"
+version = "2.39.0"
 dependencies = [
  "annotate-snippets",
  "camino",
@@ -2009,7 +2019,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-wasm"
-version = "2.37.0"
+version = "2.39.0"
 dependencies = [
  "console_error_panic_hook",
  "console_log",
@@ -2242,6 +2252,12 @@ dependencies = [
  "time-core",
 ]
 
+[[package]]
+name = "tiny_pretty"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "650d82e943da333637be9f1567d33d605e76810a26464edfd7ae74f7ef181e95"
+
 [[package]]
 name = "tinystr"
 version = "0.8.1"
@@ -2862,7 +2878,7 @@ checksum = "32ac00cd3f8ec9c1d33fb3e7958a82df6989c42d747bd326c822b1d625283547"
 
 [[package]]
 name = "xtask"
-version = "2.37.0"
+version = "2.39.0"
 dependencies = [
  "anyhow",
  "camino",

{squawk_cli-2.37.0 → squawk_cli-2.39.0}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "2.37.0"
+version = "2.39.0"
 edition = "2024"
 rust-version = "1.90.0"
 authors = ["Squawk Team & Contributors"]
@@ -31,6 +31,7 @@ serde_repr = "0.1"
 regex = "1.11.1"
 simplelog = "0.12.0"
 tempfile = "3.21.0"
+tiny_pretty = "0.2.1"
 toml = "0.5.9"
 dir-test = "0.4"
 drop_bomb = "0.1.5"
@@ -63,13 +64,13 @@ tabled = "0.17.0"
 
 # local
 # we have to make the versions explicit otherwise `cargo publish` won't work
-squawk-github = { path = "./crates/squawk_github", version = "2.37.0" }
-squawk-ide = { path = "./crates/squawk_ide", version = "2.37.0" }
-squawk-lexer = { path = "./crates/squawk_lexer", version = "2.37.0" }
-squawk-parser = { path = "./crates/squawk_parser", version = "2.37.0" }
-squawk-syntax = { path = "./crates/squawk_syntax", version = "2.37.0" }
-squawk-linter = { path = "./crates/squawk_linter", version = "2.37.0" }
-squawk-server = { path = "./crates/squawk_server", version = "2.37.0" }
+squawk-github = { path = "./crates/squawk_github", version = "2.39.0" }
+squawk-ide = { path = "./crates/squawk_ide", version = "2.39.0" }
+squawk-lexer = { path = "./crates/squawk_lexer", version = "2.39.0" }
+squawk-parser = { path = "./crates/squawk_parser", version = "2.39.0" }
+squawk-syntax = { path = "./crates/squawk_syntax", version = "2.39.0" }
+squawk-linter = { path = "./crates/squawk_linter", version = "2.39.0" }
+squawk-server = { path = "./crates/squawk_server", version = "2.39.0" }
 
 [workspace.lints.clippy]
 collapsible_else_if = "allow"

{squawk_cli-2.37.0 → squawk_cli-2.39.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: squawk-cli
-Version: 2.37.0
+Version: 2.39.0
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: MacOS

{squawk_cli-2.37.0 → squawk_cli-2.39.0}/crates/squawk/README.md

@@ -252,7 +252,7 @@ to your project's `.pre-commit-config.yaml`:
 ```yaml
 repos:
   - repo: https://github.com/sbdchd/squawk
-    rev: v0.10.0
+    rev: 2.39.0
     hooks:
       - id: squawk
         files: path/to/postgres/migrations/written/in/sql

{squawk_cli-2.37.0 → squawk_cli-2.39.0}/crates/squawk_github/src/app.rs

@@ -11,7 +11,7 @@ use serde_json::Value;
 use std::time::Duration;
 use std::time::{SystemTime, UNIX_EPOCH};
 
-pub(crate) const SQUAWK_USER_AGENT: &str = "squawk/2.37.0";
+pub(crate) const SQUAWK_USER_AGENT: &str = "squawk/2.39.0";
 
 #[derive(Debug, Serialize)]
 struct CommentBody {

{squawk_cli-2.37.0 → squawk_cli-2.39.0}/crates/squawk_ide/src/binder.rs

@@ -249,6 +249,7 @@ fn bind_file(b: &mut Binder, file: &ast::SourceFile) {
 fn bind_stmt(b: &mut Binder, stmt: ast::Stmt) {
     match stmt {
         ast::Stmt::CreateTable(create_table) => bind_create_table(b, create_table),
+        ast::Stmt::CreateTableAs(create_table_as) => bind_create_table_as(b, create_table_as),
         ast::Stmt::CreateForeignTable(create_foreign_table) => {
             bind_create_table(b, create_foreign_table)
         }
@@ -258,6 +259,7 @@ fn bind_stmt(b: &mut Binder, stmt: ast::Stmt) {
         ast::Stmt::CreateProcedure(create_procedure) => bind_create_procedure(b, create_procedure),
         ast::Stmt::CreateSchema(create_schema) => bind_create_schema(b, create_schema),
         ast::Stmt::CreateType(create_type) => bind_create_type(b, create_type),
+        ast::Stmt::CreateDomain(create_domain) => bind_create_domain(b, create_domain),
         ast::Stmt::CreateView(create_view) => bind_create_view(b, create_view),
         ast::Stmt::CreateMaterializedView(create_view) => {
             bind_create_materialized_view(b, create_view)
@@ -278,6 +280,7 @@ fn bind_stmt(b: &mut Binder, stmt: ast::Stmt) {
         ast::Stmt::Prepare(prepare) => bind_prepare(b, prepare),
         ast::Stmt::Listen(listen) => bind_listen(b, listen),
         ast::Stmt::Set(set) => bind_set(b, set),
+        ast::Stmt::CreatePolicy(create_policy) => bind_create_policy(b, create_policy),
         _ => {}
     }
 }
@@ -316,6 +319,41 @@ fn bind_create_table(b: &mut Binder, create_table: impl ast::HasCreateTable) {
     b.scopes[root].insert(table_name, type_id);
 }
 
+fn bind_create_table_as(b: &mut Binder, create_table_as: ast::CreateTableAs) {
+    let Some(path) = create_table_as.path() else {
+        return;
+    };
+    let Some(table_name) = item_name(&path) else {
+        return;
+    };
+    let name_ptr = path_to_ptr(&path);
+    let is_temp =
+        create_table_as.temp_token().is_some() || create_table_as.temporary_token().is_some();
+    let Some(schema) = schema_name(b, &path, is_temp) else {
+        return;
+    };
+
+    let table_id = b.symbols.alloc(Symbol {
+        kind: SymbolKind::Table,
+        ptr: name_ptr,
+        schema: Some(schema.clone()),
+        params: None,
+        table: None,
+    });
+
+    let type_id = b.symbols.alloc(Symbol {
+        kind: SymbolKind::Type,
+        ptr: name_ptr,
+        schema: Some(schema),
+        params: None,
+        table: None,
+    });
+
+    let root = b.root_scope();
+    b.scopes[root].insert(table_name.clone(), table_id);
+    b.scopes[root].insert(table_name, type_id);
+}
+
 fn bind_create_index(b: &mut Binder, create_index: ast::CreateIndex) {
     let Some(name) = create_index.name() else {
         return;
@@ -467,6 +505,48 @@ fn bind_create_type(b: &mut Binder, create_type: ast::CreateType) {
         return;
     };
 
+    let type_id = b.symbols.alloc(Symbol {
+        kind: SymbolKind::Type,
+        ptr: name_ptr,
+        schema: Some(schema.clone()),
+        params: None,
+        table: None,
+    });
+
+    let root = b.root_scope();
+    b.scopes[root].insert(type_name.clone(), type_id);
+
+    if create_type.range_token().is_some() {
+        if let Some((multirange_name, multirange_ptr, multirange_schema)) =
+            multirange_type_from_range(b, create_type, type_name, schema, name_ptr)
+        {
+            let multirange_id = b.symbols.alloc(Symbol {
+                kind: SymbolKind::Type,
+                ptr: multirange_ptr,
+                schema: Some(multirange_schema),
+                params: None,
+                table: None,
+            });
+            b.scopes[root].insert(multirange_name, multirange_id);
+        }
+    }
+}
+
+fn bind_create_domain(b: &mut Binder, create_domain: ast::CreateDomain) {
+    let Some(path) = create_domain.path() else {
+        return;
+    };
+
+    let Some(domain_name) = item_name(&path) else {
+        return;
+    };
+
+    let name_ptr = path_to_ptr(&path);
+
+    let Some(schema) = schema_name(b, &path, false) else {
+        return;
+    };
+
     let type_id = b.symbols.alloc(Symbol {
         kind: SymbolKind::Type,
         ptr: name_ptr,
@@ -476,7 +556,64 @@ fn bind_create_type(b: &mut Binder, create_type: ast::CreateType) {
     });
 
     let root = b.root_scope();
-    b.scopes[root].insert(type_name, type_id);
+    b.scopes[root].insert(domain_name, type_id);
+}
+
+fn multirange_type_from_range(
+    b: &Binder,
+    create_type: ast::CreateType,
+    type_name: Name,
+    schema: Schema,
+    fallback_ptr: SyntaxNodePtr,
+) -> Option<(Name, SyntaxNodePtr, Schema)> {
+    if let Some(attribute_list) = create_type.attribute_list() {
+        let multirange_key = Name::from_string("multirange_type_name");
+        for option in attribute_list.attribute_options() {
+            let Some(name) = option.name() else {
+                continue;
+            };
+            if Name::from_node(&name) != multirange_key {
+                continue;
+            }
+            if let Some(attribute_value) = option.attribute_value() {
+                if let Some(literal) = attribute_value.literal()
+                    && let Some(string_value) = extract_string_literal(&literal)
+                {
+                    let multirange_name = Name::from_string(string_value);
+                    return Some((multirange_name, fallback_ptr, schema));
+                }
+                if let Some(ast::Type::PathType(path_type)) = attribute_value.ty()
+                    && let Some(path) = path_type.path()
+                    && let Some(multirange_name) = item_name(&path)
+                {
+                    let multirange_schema = if path.qualifier().is_some() {
+                        schema_name(b, &path, false)?
+                    } else {
+                        schema
+                    };
+                    return Some((multirange_name, fallback_ptr, multirange_schema));
+                }
+            }
+        }
+    }
+
+    let multirange_name = derive_multirange_name(type_name);
+    Some((multirange_name, fallback_ptr, schema))
+}
+
+// from postgres docs:
+// > If the range type name contains the substring range, then the multirange type
+// > name is formed by replacement of the range substring with multirange in the
+// > range type name.
+// > Otherwise, the multirange type name is formed by appending a
+// > _multirange suffix to the range type name.
+fn derive_multirange_name(range_name: Name) -> Name {
+    let range_text = range_name.0.as_str();
+    if range_text.contains("range") {
+        Name::from_string(range_text.replacen("range", "multirange", 1))
+    } else {
+        Name::from_string(format!("{range_text}_multirange"))
+    }
 }
 
 fn bind_create_view(b: &mut Binder, create_view: ast::CreateView) {
@@ -596,6 +733,38 @@ fn bind_create_trigger(b: &mut Binder, create_trigger: ast::CreateTrigger) {
     b.scopes[root].insert(trigger_name, trigger_id);
 }
 
+fn bind_create_policy(b: &mut Binder, create_policy: ast::CreatePolicy) {
+    let Some(name) = create_policy.name() else {
+        return;
+    };
+
+    let policy_name = Name::from_node(&name);
+    let name_ptr = SyntaxNodePtr::new(name.syntax());
+
+    let Some(table_path) = create_policy.on_table().and_then(|on| on.path()) else {
+        return;
+    };
+
+    let Some(table_name) = item_name(&table_path) else {
+        return;
+    };
+
+    let Some(schema) = schema_name(b, &table_path, false) else {
+        return;
+    };
+
+    let policy_id = b.symbols.alloc(Symbol {
+        kind: SymbolKind::Policy,
+        ptr: name_ptr,
+        schema: Some(schema),
+        params: None,
+        table: Some(table_name),
+    });
+
+    let root = b.root_scope();
+    b.scopes[root].insert(policy_name, policy_id);
+}
+
 fn bind_create_event_trigger(b: &mut Binder, create_event_trigger: ast::CreateEventTrigger) {
     let Some(name) = create_event_trigger.name() else {
         return;