@postgres-language-server/cli-aarch64-linux-gnu 0.18.0 → 0.20.1

package/schema.json

@@ -44,6 +44,17 @@
         }
       ]
     },
+    "format": {
+      "description": "The configuration for the SQL formatter",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/FormatConfiguration"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
     "linter": {
       "description": "The configuration for the linter",
       "anyOf": [
@@ -66,6 +77,17 @@
         }
       ]
     },
+    "pglinter": {
+      "description": "The configuration for pglinter",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/PglinterConfiguration"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
     "plpgsqlCheck": {
       "description": "The configuration for type checking",
       "anyOf": [
@@ -77,6 +99,17 @@
         }
       ]
     },
+    "splinter": {
+      "description": "The configuration for splinter",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/SplinterConfiguration"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
     "typecheck": {
       "description": "The configuration for type checking",
       "anyOf": [
@@ -102,6 +135,213 @@
   },
   "additionalProperties": false,
   "definitions": {
+    "Base": {
+      "description": "A list of rules that belong to this group",
+      "type": "object",
+      "properties": {
+        "all": {
+          "description": "It enables ALL rules for this group.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "compositePrimaryKeyTooManyColumns": {
+          "description": "CompositePrimaryKeyTooManyColumns (B012): Detect tables with composite primary keys involving more than 4 columns",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "howManyObjectsWithUppercase": {
+          "description": "HowManyObjectsWithUppercase (B005): Count number of objects with uppercase in name or in columns.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "howManyRedudantIndex": {
+          "description": "HowManyRedudantIndex (B002): Count number of redundant index vs nb index.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "howManyTableWithoutIndexOnFk": {
+          "description": "HowManyTableWithoutIndexOnFk (B003): Count number of tables without index on foreign key.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "howManyTableWithoutPrimaryKey": {
+          "description": "HowManyTableWithoutPrimaryKey (B001): Count number of tables without primary key.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "howManyTablesNeverSelected": {
+          "description": "HowManyTablesNeverSelected (B006): Count number of table(s) that has never been selected.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "howManyTablesWithFkMismatch": {
+          "description": "HowManyTablesWithFkMismatch (B008): Count number of tables with foreign keys that do not match the key reference type.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "howManyTablesWithFkOutsideSchema": {
+          "description": "HowManyTablesWithFkOutsideSchema (B007): Count number of tables with foreign keys outside their schema.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "howManyTablesWithReservedKeywords": {
+          "description": "HowManyTablesWithReservedKeywords (B010): Count number of database objects using reserved keywords in their names.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "howManyTablesWithSameTrigger": {
+          "description": "HowManyTablesWithSameTrigger (B009): Count number of tables using the same trigger vs nb table with their own triggers.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "howManyUnusedIndex": {
+          "description": "HowManyUnusedIndex (B004): Count number of unused index vs nb index (base on pg_stat_user_indexes, indexes associated to unique constraints are discard.)",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "recommended": {
+          "description": "It enables the recommended rules for this group",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "severalTableOwnerInSchema": {
+          "description": "SeveralTableOwnerInSchema (B011): In a schema there are several tables owned by different owners.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "Cluster": {
+      "description": "A list of rules that belong to this group",
+      "type": "object",
+      "properties": {
+        "all": {
+          "description": "It enables ALL rules for this group.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "passwordEncryptionIsMd5": {
+          "description": "PasswordEncryptionIsMd5 (C003): This configuration is not secure anymore and will prevent an upgrade to Postgres 18. Warning, you will need to reset all passwords after this is changed to scram-sha-256.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "pgHbaEntriesWithMethodTrustOrPasswordShouldNotExists": {
+          "description": "PgHbaEntriesWithMethodTrustOrPasswordShouldNotExists (C002): This configuration is extremely insecure and should only be used in a controlled, non-production environment for testing purposes. In a production environment, you should use more secure authentication methods such as md5, scram-sha-256, or cert, and restrict access to trusted IP addresses only.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "pgHbaEntriesWithMethodTrustShouldNotExists": {
+          "description": "PgHbaEntriesWithMethodTrustShouldNotExists (C001): This configuration is extremely insecure and should only be used in a controlled, non-production environment for testing purposes. In a production environment, you should use more secure authentication methods such as md5, scram-sha-256, or cert, and restrict access to trusted IP addresses only.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "recommended": {
+          "description": "It enables the recommended rules for this group",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
     "DatabaseConfiguration": {
       "description": "The configuration of the database connection.",
       "type": "object",
@@ -210,11 +450,23 @@
       },
       "additionalProperties": false
     },
-    "LinterConfiguration": {
+    "FormatConfiguration": {
+      "description": "The configuration for SQL formatting.",
       "type": "object",
       "properties": {
+        "constantCase": {
+          "description": "Constant casing (NULL, TRUE, FALSE): \"upper\" or \"lower\". Default: \"lower\".",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/KeywordCase"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
         "enabled": {
-          "description": "if `false`, it disables the feature and the linter won't be executed. `true` by default",
+          "description": "If `false`, it disables the formatter. `true` by default.",
           "type": [
             "boolean",
             "null"
@@ -242,50 +494,376 @@
             }
           ]
         },
-        "rules": {
-          "description": "List of rules",
+        "indentSize": {
+          "description": "Number of spaces (or tab width) for indentation. Default: 2.",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint8",
+          "minimum": 0.0
+        },
+        "indentStyle": {
+          "description": "Indentation style: \"spaces\" or \"tabs\". Default: \"spaces\".",
           "anyOf": [
             {
-              "$ref": "#/definitions/Rules"
+              "$ref": "#/definitions/IndentStyle"
             },
             {
               "type": "null"
             }
           ]
-        }
-      },
-      "additionalProperties": false
-    },
-    "MigrationsConfiguration": {
-      "description": "The configuration of the filesystem",
-      "type": "object",
-      "properties": {
-        "after": {
-          "description": "Ignore any migrations before this timestamp",
+        },
+        "keywordCase": {
+          "description": "Keyword casing: \"upper\" or \"lower\". Default: \"lower\".",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/KeywordCase"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "lineWidth": {
+          "description": "Maximum line width before breaking. Default: 100.",
           "type": [
             "integer",
             "null"
           ],
-          "format": "uint64",
+          "format": "uint16",
           "minimum": 0.0
         },
-        "migrationsDir": {
-          "description": "The directory where the migration files are stored",
-          "type": [
-            "string",
-            "null"
+        "typeCase": {
+          "description": "Data type casing (text, varchar, int): \"upper\" or \"lower\". Default: \"lower\".",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/KeywordCase"
+            },
+            {
+              "type": "null"
+            }
           ]
         }
       },
       "additionalProperties": false
     },
-    "PlPgSqlCheckConfiguration": {
-      "description": "The configuration for type checking.",
-      "type": "object",
-      "properties": {
-        "enabled": {
-          "description": "if `false`, it disables the feature and pglpgsql_check won't be executed. `true` by default",
-          "type": [
+    "IndentStyle": {
+      "description": "Indentation style for the formatter.",
+      "oneOf": [
+        {
+          "description": "Use spaces for indentation (default).",
+          "type": "string",
+          "enum": [
+            "spaces"
+          ]
+        },
+        {
+          "description": "Use tabs for indentation.",
+          "type": "string",
+          "enum": [
+            "tabs"
+          ]
+        }
+      ]
+    },
+    "KeywordCase": {
+      "description": "Keyword casing style for the formatter.",
+      "oneOf": [
+        {
+          "description": "Use uppercase keywords (SELECT, FROM, WHERE).",
+          "type": "string",
+          "enum": [
+            "upper"
+          ]
+        },
+        {
+          "description": "Use lowercase keywords (select, from, where). Default.",
+          "type": "string",
+          "enum": [
+            "lower"
+          ]
+        }
+      ]
+    },
+    "LinterConfiguration": {
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "description": "if `false`, it disables the feature and the linter won't be executed. `true` by default",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "ignore": {
+          "description": "A list of Unix shell style patterns. The linter will ignore files/folders that will match these patterns.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/StringSet"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "include": {
+          "description": "A list of Unix shell style patterns. The linter will include files/folders that will match these patterns.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/StringSet"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "rules": {
+          "description": "List of rules",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/LinterRules"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "LinterRules": {
+      "type": "object",
+      "properties": {
+        "all": {
+          "description": "It enables ALL rules. The rules that belong to `nursery` won't be enabled.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "recommended": {
+          "description": "It enables the lint rules recommended by Postgres Language Server. `true` by default.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "safety": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Safety"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "MigrationsConfiguration": {
+      "description": "The configuration of the filesystem",
+      "type": "object",
+      "properties": {
+        "after": {
+          "description": "Ignore any migrations before this timestamp",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint64",
+          "minimum": 0.0
+        },
+        "migrationsDir": {
+          "description": "The directory where the migration files are stored",
+          "type": [
+            "string",
+            "null"
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "Performance": {
+      "description": "A list of rules that belong to this group",
+      "type": "object",
+      "properties": {
+        "all": {
+          "description": "It enables ALL rules for this group.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "authRlsInitplan": {
+          "description": "Auth RLS Initialization Plan: Detects if calls to `current_setting()` and `auth.()` in RLS policies are being unnecessarily re-evaluated for each row",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/SplinterRuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "duplicateIndex": {
+          "description": "Duplicate Index: Detects cases where two ore more identical indexes exist.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/SplinterRuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "multiplePermissivePolicies": {
+          "description": "Multiple Permissive Policies: Detects if multiple permissive row level security policies are present on a table for the same `role` and `action` (e.g. insert). Multiple permissive policies are suboptimal for performance as each policy must be executed for every relevant query.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/SplinterRuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "noPrimaryKey": {
+          "description": "No Primary Key: Detects if a table does not have a primary key. Tables without a primary key can be inefficient to interact with at scale.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/SplinterRuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "recommended": {
+          "description": "It enables the recommended rules for this group",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "tableBloat": {
+          "description": "Table Bloat: Detects if a table has excess bloat and may benefit from maintenance operations like vacuum full or cluster.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/SplinterRuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "unindexedForeignKeys": {
+          "description": "Unindexed foreign keys: Identifies foreign key constraints without a covering index, which can impact database performance.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/SplinterRuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "unusedIndex": {
+          "description": "Unused Index: Detects if an index has never been used and may be a candidate for removal.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/SplinterRuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "PglinterConfiguration": {
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "description": "if `false`, it disables the feature and the linter won't be executed. `true` by default",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "rules": {
+          "description": "List of rules",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/PglinterRules"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "PglinterRules": {
+      "type": "object",
+      "properties": {
+        "all": {
+          "description": "It enables ALL rules. The rules that belong to `nursery` won't be enabled.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "base": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Base"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "cluster": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Cluster"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "recommended": {
+          "description": "It enables the lint rules recommended by Postgres Language Server. `true` by default.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "schema": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Schema"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "PlPgSqlCheckConfiguration": {
+      "description": "The configuration for type checking.",
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "description": "if `false`, it disables the feature and pglpgsql_check won't be executed. `true` by default",
+          "type": [
             "boolean",
             "null"
           ]
@@ -329,42 +907,254 @@
       },
       "additionalProperties": false
     },
-    "Rules": {
+    "RuleWithSplinterRuleOptions": {
       "type": "object",
+      "required": [
+        "level",
+        "options"
+      ],
       "properties": {
+        "level": {
+          "description": "The severity of the emitted diagnostics by the rule",
+          "allOf": [
+            {
+              "$ref": "#/definitions/RulePlainConfiguration"
+            }
+          ]
+        },
+        "options": {
+          "description": "Rule's options",
+          "allOf": [
+            {
+              "$ref": "#/definitions/SplinterRuleOptions"
+            }
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "Safety": {
+      "description": "A list of rules that belong to this group",
+      "type": "object",
+      "properties": {
+        "addSerialColumn": {
+          "description": "Adding a column with a SERIAL type or GENERATED ALWAYS AS ... STORED causes a full table rewrite.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "addingFieldWithDefault": {
+          "description": "Adding a column with a DEFAULT value may lead to a table rewrite while holding an ACCESS EXCLUSIVE lock.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "addingForeignKeyConstraint": {
+          "description": "Adding a foreign key constraint requires a table scan and a SHARE ROW EXCLUSIVE lock on both tables, which blocks writes.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "addingNotNullField": {
+          "description": "Setting a column NOT NULL blocks reads while the table is scanned.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "addingPrimaryKeyConstraint": {
+          "description": "Adding a primary key constraint results in locks and table rewrites.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "addingRequiredField": {
+          "description": "Adding a new column that is NOT NULL and has no default value to an existing table effectively makes it required.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
         "all": {
-          "description": "It enables ALL rules. The rules that belong to `nursery` won't be enabled.",
+          "description": "It enables ALL rules for this group.",
           "type": [
             "boolean",
             "null"
           ]
         },
-        "recommended": {
-          "description": "It enables the lint rules recommended by Postgres Language Server. `true` by default.",
-          "type": [
-            "boolean",
-            "null"
+        "banCharField": {
+          "description": "Using CHAR(n) or CHARACTER(n) types is discouraged.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "banConcurrentIndexCreationInTransaction": {
+          "description": "Concurrent index creation is not allowed within a transaction.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "banDropColumn": {
+          "description": "Dropping a column may break existing clients.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "banDropDatabase": {
+          "description": "Dropping a database may break existing clients (and everything else, really).",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "banDropNotNull": {
+          "description": "Dropping a NOT NULL constraint may break existing clients.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "banDropTable": {
+          "description": "Dropping a table may break existing clients.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "banTruncateCascade": {
+          "description": "Using TRUNCATE's CASCADE option will truncate any tables that are also foreign-keyed to the specified tables.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "changingColumnType": {
+          "description": "Changing a column type may break existing clients.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "constraintMissingNotValid": {
+          "description": "Adding constraints without NOT VALID blocks all reads and writes.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "creatingEnum": {
+          "description": "Creating enum types is not recommended for new applications.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "disallowUniqueConstraint": {
+          "description": "Disallow adding a UNIQUE constraint without using an existing index.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "lockTimeoutWarning": {
+          "description": "Taking a dangerous lock without setting a lock timeout can cause indefinite blocking.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
           ]
         },
-        "safety": {
+        "multipleAlterTable": {
+          "description": "Multiple ALTER TABLE statements on the same table should be combined into a single statement.",
           "anyOf": [
             {
-              "$ref": "#/definitions/Safety"
+              "$ref": "#/definitions/RuleConfiguration"
             },
             {
               "type": "null"
             }
           ]
-        }
-      },
-      "additionalProperties": false
-    },
-    "Safety": {
-      "description": "A list of rules that belong to this group",
-      "type": "object",
-      "properties": {
-        "addSerialColumn": {
-          "description": "Adding a column with a SERIAL type or GENERATED ALWAYS AS ... STORED causes a full table rewrite.",
+        },
+        "preferBigInt": {
+          "description": "Prefer BIGINT over smaller integer types.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -374,8 +1164,8 @@
             }
           ]
         },
-        "addingFieldWithDefault": {
-          "description": "Adding a column with a DEFAULT value may lead to a table rewrite while holding an ACCESS EXCLUSIVE lock.",
+        "preferBigintOverInt": {
+          "description": "Prefer BIGINT over INT/INTEGER types.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -385,8 +1175,8 @@
             }
           ]
         },
-        "addingForeignKeyConstraint": {
-          "description": "Adding a foreign key constraint requires a table scan and a SHARE ROW EXCLUSIVE lock on both tables, which blocks writes.",
+        "preferBigintOverSmallint": {
+          "description": "Prefer BIGINT over SMALLINT types.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -396,8 +1186,8 @@
             }
           ]
         },
-        "addingNotNullField": {
-          "description": "Setting a column NOT NULL blocks reads while the table is scanned.",
+        "preferIdentity": {
+          "description": "Prefer using IDENTITY columns over serial columns.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -407,8 +1197,8 @@
             }
           ]
         },
-        "addingPrimaryKeyConstraint": {
-          "description": "Adding a primary key constraint results in locks and table rewrites.",
+        "preferJsonb": {
+          "description": "Prefer JSONB over JSON types.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -418,8 +1208,8 @@
             }
           ]
         },
-        "addingRequiredField": {
-          "description": "Adding a new column that is NOT NULL and has no default value to an existing table effectively makes it required.",
+        "preferRobustStmts": {
+          "description": "Prefer statements with guards for robustness in migrations.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -429,15 +1219,19 @@
             }
           ]
         },
-        "all": {
-          "description": "It enables ALL rules for this group.",
-          "type": [
-            "boolean",
-            "null"
+        "preferTextField": {
+          "description": "Prefer using TEXT over VARCHAR(n) types.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RuleConfiguration"
+            },
+            {
+              "type": "null"
+            }
           ]
         },
-        "banCharField": {
-          "description": "Using CHAR(n) or CHARACTER(n) types is discouraged.",
+        "preferTimestamptz": {
+          "description": "Prefer TIMESTAMPTZ over TIMESTAMP types.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -447,8 +1241,15 @@
             }
           ]
         },
-        "banConcurrentIndexCreationInTransaction": {
-          "description": "Concurrent index creation is not allowed within a transaction.",
+        "recommended": {
+          "description": "It enables the recommended rules for this group",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "renamingColumn": {
+          "description": "Renaming columns may break existing queries and application code.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -458,8 +1259,8 @@
             }
           ]
         },
-        "banDropColumn": {
-          "description": "Dropping a column may break existing clients.",
+        "renamingTable": {
+          "description": "Renaming tables may break existing queries and application code.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -469,8 +1270,8 @@
             }
           ]
         },
-        "banDropDatabase": {
-          "description": "Dropping a database may break existing clients (and everything else, really).",
+        "requireConcurrentIndexCreation": {
+          "description": "Creating indexes non-concurrently can lock the table for writes.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -480,8 +1281,8 @@
             }
           ]
         },
-        "banDropNotNull": {
-          "description": "Dropping a NOT NULL constraint may break existing clients.",
+        "requireConcurrentIndexDeletion": {
+          "description": "Dropping indexes non-concurrently can lock the table for reads.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -491,8 +1292,8 @@
             }
           ]
         },
-        "banDropTable": {
-          "description": "Dropping a table may break existing clients.",
+        "runningStatementWhileHoldingAccessExclusive": {
+          "description": "Running additional statements while holding an ACCESS EXCLUSIVE lock blocks all table access.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -502,8 +1303,8 @@
             }
           ]
         },
-        "banTruncateCascade": {
-          "description": "Using TRUNCATE's CASCADE option will truncate any tables that are also foreign-keyed to the specified tables.",
+        "transactionNesting": {
+          "description": "Detects problematic transaction nesting that could lead to unexpected behavior.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -512,9 +1313,23 @@
               "type": "null"
             }
           ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "Schema": {
+      "description": "A list of rules that belong to this group",
+      "type": "object",
+      "properties": {
+        "all": {
+          "description": "It enables ALL rules for this group.",
+          "type": [
+            "boolean",
+            "null"
+          ]
         },
-        "changingColumnType": {
-          "description": "Changing a column type may break existing clients.",
+        "ownerSchemaIsInternalRole": {
+          "description": "OwnerSchemaIsInternalRole (S004): Owner of schema should not be any internal pg roles, or owner is a superuser (not sure it is necesary).",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -524,8 +1339,15 @@
             }
           ]
         },
-        "constraintMissingNotValid": {
-          "description": "Adding constraints without NOT VALID blocks all reads and writes.",
+        "recommended": {
+          "description": "It enables the recommended rules for this group",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "schemaOwnerDoNotMatchTableOwner": {
+          "description": "SchemaOwnerDoNotMatchTableOwner (S005): The schema owner and tables in the schema do not match.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -535,8 +1357,8 @@
             }
           ]
         },
-        "creatingEnum": {
-          "description": "Creating enum types is not recommended for new applications.",
+        "schemaPrefixedOrSuffixedWithEnvt": {
+          "description": "SchemaPrefixedOrSuffixedWithEnvt (S002): The schema is prefixed with one of staging,stg,preprod,prod,sandbox,sbox string. Means that when you refresh your preprod, staging environments from production, you have to rename the target schema from prod_ to stg_ or something like. It is possible, but it is never easy.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -546,8 +1368,8 @@
             }
           ]
         },
-        "disallowUniqueConstraint": {
-          "description": "Disallow adding a UNIQUE constraint without using an existing index.",
+        "schemaWithDefaultRoleNotGranted": {
+          "description": "SchemaWithDefaultRoleNotGranted (S001): The schema has no default role. Means that futur table will not be granted through a role. So you will have to re-execute grants on it.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -557,8 +1379,8 @@
             }
           ]
         },
-        "lockTimeoutWarning": {
-          "description": "Taking a dangerous lock without setting a lock timeout can cause indefinite blocking.",
+        "unsecuredPublicSchema": {
+          "description": "UnsecuredPublicSchema (S003): Only authorized users should be allowed to create objects.",
           "anyOf": [
             {
               "$ref": "#/definitions/RuleConfiguration"
@@ -567,100 +1389,114 @@
               "type": "null"
             }
           ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "Security": {
+      "description": "A list of rules that belong to this group",
+      "type": "object",
+      "properties": {
+        "all": {
+          "description": "It enables ALL rules for this group.",
+          "type": [
+            "boolean",
+            "null"
+          ]
         },
-        "multipleAlterTable": {
-          "description": "Multiple ALTER TABLE statements on the same table should be combined into a single statement.",
+        "authUsersExposed": {
+          "description": "Exposed Auth Users: Detects if auth.users is exposed to anon or authenticated roles via a view or materialized view in schemas exposed to PostgREST, potentially compromising user data security.",
           "anyOf": [
             {
-              "$ref": "#/definitions/RuleConfiguration"
+              "$ref": "#/definitions/SplinterRuleConfiguration"
             },
             {
               "type": "null"
             }
           ]
         },
-        "preferBigInt": {
-          "description": "Prefer BIGINT over smaller integer types.",
+        "extensionInPublic": {
+          "description": "Extension in Public: Detects extensions installed in the `public` schema.",
           "anyOf": [
             {
-              "$ref": "#/definitions/RuleConfiguration"
+              "$ref": "#/definitions/SplinterRuleConfiguration"
             },
             {
               "type": "null"
             }
           ]
         },
-        "preferBigintOverInt": {
-          "description": "Prefer BIGINT over INT/INTEGER types.",
+        "extensionVersionsOutdated": {
+          "description": "Extension Versions Outdated: Detects extensions that are not using the default (recommended) version.",
           "anyOf": [
             {
-              "$ref": "#/definitions/RuleConfiguration"
+              "$ref": "#/definitions/SplinterRuleConfiguration"
             },
             {
               "type": "null"
             }
           ]
         },
-        "preferBigintOverSmallint": {
-          "description": "Prefer BIGINT over SMALLINT types.",
+        "fkeyToAuthUnique": {
+          "description": "Foreign Key to Auth Unique Constraint: Detects user defined foreign keys to unique constraints in the auth schema.",
           "anyOf": [
             {
-              "$ref": "#/definitions/RuleConfiguration"
+              "$ref": "#/definitions/SplinterRuleConfiguration"
             },
             {
               "type": "null"
             }
           ]
         },
-        "preferIdentity": {
-          "description": "Prefer using IDENTITY columns over serial columns.",
+        "foreignTableInApi": {
+          "description": "Foreign Table in API: Detects foreign tables that are accessible over APIs. Foreign tables do not respect row level security policies.",
           "anyOf": [
             {
-              "$ref": "#/definitions/RuleConfiguration"
+              "$ref": "#/definitions/SplinterRuleConfiguration"
             },
             {
               "type": "null"
             }
           ]
         },
-        "preferJsonb": {
-          "description": "Prefer JSONB over JSON types.",
+        "functionSearchPathMutable": {
+          "description": "Function Search Path Mutable: Detects functions where the search_path parameter is not set.",
           "anyOf": [
             {
-              "$ref": "#/definitions/RuleConfiguration"
+              "$ref": "#/definitions/SplinterRuleConfiguration"
             },
             {
               "type": "null"
             }
           ]
         },
-        "preferRobustStmts": {
-          "description": "Prefer statements with guards for robustness in migrations.",
+        "insecureQueueExposedInApi": {
+          "description": "Insecure Queue Exposed in API: Detects cases where an insecure Queue is exposed over Data APIs",
           "anyOf": [
             {
-              "$ref": "#/definitions/RuleConfiguration"
+              "$ref": "#/definitions/SplinterRuleConfiguration"
             },
             {
               "type": "null"
             }
           ]
         },
-        "preferTextField": {
-          "description": "Prefer using TEXT over VARCHAR(n) types.",
+        "materializedViewInApi": {
+          "description": "Materialized View in API: Detects materialized views that are accessible over the Data APIs.",
           "anyOf": [
             {
-              "$ref": "#/definitions/RuleConfiguration"
+              "$ref": "#/definitions/SplinterRuleConfiguration"
             },
             {
               "type": "null"
             }
           ]
         },
-        "preferTimestamptz": {
-          "description": "Prefer TIMESTAMPTZ over TIMESTAMP types.",
+        "policyExistsRlsDisabled": {
+          "description": "Policy Exists RLS Disabled: Detects cases where row level security (RLS) policies have been created, but RLS has not been enabled for the underlying table.",
           "anyOf": [
             {
-              "$ref": "#/definitions/RuleConfiguration"
+              "$ref": "#/definitions/SplinterRuleConfiguration"
             },
             {
               "type": "null"
@@ -674,66 +1510,155 @@
             "null"
           ]
         },
-        "renamingColumn": {
-          "description": "Renaming columns may break existing queries and application code.",
+        "rlsDisabledInPublic": {
+          "description": "RLS Disabled in Public: Detects cases where row level security (RLS) has not been enabled on tables in schemas exposed to PostgREST",
           "anyOf": [
             {
-              "$ref": "#/definitions/RuleConfiguration"
+              "$ref": "#/definitions/SplinterRuleConfiguration"
             },
             {
               "type": "null"
             }
           ]
         },
-        "renamingTable": {
-          "description": "Renaming tables may break existing queries and application code.",
+        "rlsEnabledNoPolicy": {
+          "description": "RLS Enabled No Policy: Detects cases where row level security (RLS) has been enabled on a table but no RLS policies have been created.",
           "anyOf": [
             {
-              "$ref": "#/definitions/RuleConfiguration"
+              "$ref": "#/definitions/SplinterRuleConfiguration"
             },
             {
               "type": "null"
             }
           ]
         },
-        "requireConcurrentIndexCreation": {
-          "description": "Creating indexes non-concurrently can lock the table for writes.",
+        "rlsReferencesUserMetadata": {
+          "description": "RLS references user metadata: Detects when Supabase Auth user_metadata is referenced insecurely in a row level security (RLS) policy.",
           "anyOf": [
             {
-              "$ref": "#/definitions/RuleConfiguration"
+              "$ref": "#/definitions/SplinterRuleConfiguration"
             },
             {
               "type": "null"
             }
           ]
         },
-        "requireConcurrentIndexDeletion": {
-          "description": "Dropping indexes non-concurrently can lock the table for reads.",
+        "securityDefinerView": {
+          "description": "Security Definer View: Detects views defined with the SECURITY DEFINER property. These views enforce Postgres permissions and row level security policies (RLS) of the view creator, rather than that of the querying user",
           "anyOf": [
             {
-              "$ref": "#/definitions/RuleConfiguration"
+              "$ref": "#/definitions/SplinterRuleConfiguration"
             },
             {
               "type": "null"
             }
           ]
         },
-        "runningStatementWhileHoldingAccessExclusive": {
-          "description": "Running additional statements while holding an ACCESS EXCLUSIVE lock blocks all table access.",
+        "unsupportedRegTypes": {
+          "description": "Unsupported reg types: Identifies columns using unsupported reg* types outside pg_catalog schema, which prevents database upgrades using pg_upgrade.",
           "anyOf": [
             {
-              "$ref": "#/definitions/RuleConfiguration"
+              "$ref": "#/definitions/SplinterRuleConfiguration"
             },
             {
               "type": "null"
             }
           ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "SplinterConfiguration": {
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "description": "if `false`, it disables the feature and the linter won't be executed. `true` by default",
+          "type": [
+            "boolean",
+            "null"
+          ]
         },
-        "transactionNesting": {
-          "description": "Detects problematic transaction nesting that could lead to unexpected behavior.",
+        "ignore": {
+          "description": "A list of glob patterns for database objects to ignore across all rules. Patterns use Unix-style globs where `*` matches any sequence of characters. Format: `schema.object_name`, e.g., \"public.my_table\", \"audit.*\"",
           "anyOf": [
             {
-              "$ref": "#/definitions/RuleConfiguration"
+              "$ref": "#/definitions/StringSet"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "rules": {
+          "description": "List of rules",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/SplinterRules"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "SplinterRuleConfiguration": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/RulePlainConfiguration"
+        },
+        {
+          "$ref": "#/definitions/RuleWithSplinterRuleOptions"
+        }
+      ]
+    },
+    "SplinterRuleOptions": {
+      "description": "Shared options for all splinter rules.\n\nThese options allow configuring per-rule filtering of database objects.",
+      "type": "object",
+      "properties": {
+        "ignore": {
+          "description": "A list of glob patterns for database objects to ignore.\n\nPatterns use Unix-style globs where: - `*` matches any sequence of characters - `?` matches any single character\n\nEach pattern should be in the format `schema.object_name`, for example: - `\"public.my_table\"` - ignores a specific table - `\"audit.*\"` - ignores all objects in the audit schema - `\"*.audit_*\"` - ignores objects with audit_ prefix in any schema",
+          "default": [],
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      },
+      "additionalProperties": false
+    },
+    "SplinterRules": {
+      "type": "object",
+      "properties": {
+        "all": {
+          "description": "It enables ALL rules. The rules that belong to `nursery` won't be enabled.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "performance": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Performance"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "recommended": {
+          "description": "It enables the lint rules recommended by Postgres Language Server. `true` by default.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "security": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Security"
             },
             {
               "type": "null"