package
SQL linting rules for ESLint.
npm install eslint-plugin-sqlGitHub-flavored package documentation.
Across all versions.
Download trend unavailable.
Runtime metadata.
Tagged topics.
SQL linting rules for ESLint.
In its current form, the plugin has been designed and tested to work with Postgres codebase.
eslint-plugin-sql plugin.npm install eslint --save-dev
npm install eslint-plugin-sql --save-devplugins section and specify eslint-plugin-sql as a plugin.{
"plugins": [
"sql"
],
"rules": {
"sql/format": [
2,
{
"ignoreExpressions": false,
"ignoreInline": true,
"ignoreTagless": true
}
],
"sql/no-unsafe-query": [
2,
{
"allowLiteral": false
}
]
}
}
placeholderRuleA regex used to ignore placeholders or other fragments of the query that'd make it invalid SQL query, e.g.
If you are using ? placeholders in your queries, you must ignore \? pattern as otherwise the string is not going to be recognized as a valid SQL query.
This configuration is relevant for sql/no-unsafe-query to match queries containing placeholders as well as for sql/format when used with {ignoreTagless: false} configuration.
formatThe --fix option on the command line automatically fixes problems reported by this rule.
Matches queries in template literals. Warns when query formatting does not match the configured format (see Options).
This rule is used to format the queries using sql-formatter.
The first option is an object with the following configuration.
| configuration | format | default | description |
|---|---|---|---|
ignoreExpressions | boolean | false | Does not format template literals that contain expressions. |
ignoreInline | boolean | true | Does not format queries that are written on a single line. |
ignoreStartWithNewLine | boolean | true | Does not remove \n at the beginning of queries. |
ignoreTagless | boolean | true | Does not format queries that are written without using sql tag. |
retainBaseIndent | boolean |
The second option is an object with the sql-formatter configuration.
| configuration | default | description |
|---|---|---|
useTabs | false | Use tabs for indentation. |
tabSize | 2 | Number of spaces per indentation. |
language | sql | Language of the query. |
keywordCase | preserve | Determines the case of keywords (preserve, upper, lower). |
dataTypeCase | preserve | Determines the case of data types (preserve, upper, lower). |
denseOperators | false | Decides whitespace around operators. |
Different SQL dialects support different placeholder styles. By default, sql-formatter uses dialect-specific placeholders (e.g., $1, $2 for PostgreSQL, ? for MySQL). If you're using a different placeholder style like :name, you need to configure paramTypes.
For example, if you're using :name style placeholders with PostgreSQL:
{
"rules": {
"sql/format": [
2,
{
"sqlTag": "sql"
},
{
"language": "postgresql",
"paramTypes": {
"named": [":"]
}
}
]
}
}The paramTypes object supports:
| property | type | description |
|---|---|---|
positional | boolean | Enable ? positional placeholders. |
numbered | ('$' | ':' | '?')[] | Prefixes for numbered placeholders (e.g., $1, :1). |
named | ('$' | ':' | '@')[] | Prefixes for named placeholders (e.g., :name, @name). |
quoted | ('$' | ':' | '@')[] | Prefixes for quoted placeholders (e.g., :"name"). |
custom | { regex: string }[] | Custom placeholder patterns using regex. |
The following patterns are considered problems:
sql.fragment`
SELECT
m1.ID
FROM
message m1
WHERE
m1.ID = ${message.id}
`
// Options: [{},{"identifierCase":"lower"}]
// Message: undefined
// Fixed code:
// sql.fragment`
// SELECT
// m1.id
// FROM
// message m1
// WHERE
// m1.id = ${message.id}
// `
sql.fragment`
SELECT id::NUMERIC
`
// Options: [{},{"dataTypeCase":"lower","language":"postgresql"}]
// Message: undefined
// Fixed code:
// sql.fragment`
// SELECT
// id::numeric
The following patterns are not considered problems:
`
# A
## B
### C
`
sql`SELECT 1`
// Options: [{"ignoreInline":true},{}]
`SELECT 2`
// Options: [{"ignoreTagless":true},{}]
const code = sql`
SELECT
${'foo'}
FROM
${'bar'}
`
// Options: [{"ignoreExpressions":true,"ignoreInline":false,"ignoreTagless":false},{}]
const code = sql`
SELECT
${'foo'}
FROM
${'bar'}
`
// Options: [{},{}]
const code = sql`
DROP TABLE foo
no-unsafe-queryDisallows use of SQL inside of template literals without the sql tag.
The sql tag can be anything, e.g.
The first option is an object with the following configuration.
| configuration | format | default | description |
|---|---|---|---|
allowLiteral | boolean | false | Controls whether sql tag is required for template literals containing literal queries, i.e. template literals without expressions. |
sqlTag | string | sql | Template tag name for SQL. |
The following patterns are considered problems:
`SELECT 1`
// Message: undefined
`SELECT ${'foo'}`
// Message: undefined
foo`SELECT ${'bar'}`
// Message: undefined
`SELECT ?`
// Message: undefined
foo`SELECT ${'bar'}`
// Options: [{"sqlTag":"SQL"}]
// Message: undefinedThe following patterns are not considered problems:
sql.unsafe`SELECT 3`
`SELECT 1`
// Options: [{"allowLiteral":true}]
sql`SELECT 1`
sql`SELECT ${'foo'}`
SQL`SELECT ${'bar'}`
// Options: [{"sqlTag":"SQL"}]true| Uses the first line of the query as the base indent. |
sqlTag | string | sql | Template tag name for SQL. |
identifierCasepreserve |
Determines the case of identifiers (preserve, upper, lower). |
functionCase | preserve | Determines the case of functions (preserve, upper, lower). |
paramTypes | dialect default | Configures parameter placeholders. See paramTypes documentation. |
Estimated unpacked size across 26 packages.
7.6 MB
Includes dependencies.
6 direct dependencies.
^4.4.3
4.4.3
^4.17.21
4.18.1
^0.1.5
0.1.5
^4.0.1
4.0.1
^15.6.12
15.9.0
^8.53.0
8.72.2