@pgsql/lint 18.1.1 → 18.2.0

package/esm/ignore.js

@@ -0,0 +1,101 @@
+/**
+ * Path exclusion for the file runner — `--ignore` / `ignore` in a config file.
+ *
+ * Most repositories that lint SQL on disk also *generate* SQL on disk
+ * (packaged modules, introspected schemas, codegen output), and linting
+ * generated output is noise. Patterns are gitignore-flavoured globs matched
+ * against the path relative to `cwd`:
+ *
+ *   - `*` matches within a segment, `**` across segments, `?` one character.
+ *   - A pattern with no glob character matches that path *and everything under
+ *     it*, so `sql/` and `sql` both exclude `sql/app--1.0.0.sql`.
+ *   - An unanchored pattern (no leading `/`) also matches at any segment
+ *     boundary, so `generated/`, `**` patterns, and `*.gen.sql` all work.
+ *   - A leading `/` anchors the pattern to `cwd`.
+ */
+import * as path from 'path';
+/** Turn a glob into a `RegExp` source anchored at both ends. */
+function globToRegExpSource(glob) {
+    let out = '';
+    for (let i = 0; i < glob.length; i++) {
+        const ch = glob[i];
+        if (ch === '*') {
+            if (glob[i + 1] === '*') {
+                // `**/` may match zero segments, so `**/gen/**` also matches `gen/x`.
+                if (glob[i + 2] === '/') {
+                    out += '(?:.*/)?';
+                    i += 2;
+                }
+                else {
+                    out += '.*';
+                    i += 1;
+                }
+            }
+            else {
+                out += '[^/]*';
+            }
+            continue;
+        }
+        if (ch === '?') {
+            out += '[^/]';
+            continue;
+        }
+        out += ch.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    }
+    return out;
+}
+function compile(pattern) {
+    let p = pattern.trim().replace(/\\/g, '/');
+    if (!p || p.startsWith('#'))
+        return null;
+    const anchored = p.startsWith('/');
+    if (anchored)
+        p = p.slice(1);
+    p = p.replace(/^\.\//, '');
+    const dirOnly = p.endsWith('/');
+    if (dirOnly)
+        p = p.replace(/\/+$/, '');
+    if (!p)
+        return null;
+    // A plain path (or an explicit directory) excludes the subtree under it.
+    const source = /[*?]/.test(p) && !dirOnly
+        ? globToRegExpSource(p)
+        : `${globToRegExpSource(p)}(?:/.*)?`;
+    return { re: new RegExp(`^${source}$`), anchored };
+}
+/**
+ * Build a predicate that answers "is this file ignored?". Paths may be
+ * absolute or relative; both are compared as `cwd`-relative POSIX paths.
+ */
+export function makeIgnoreFilter(patterns = [], cwd = process.cwd()) {
+    const compiled = patterns.map(compile).filter((c) => c !== null);
+    if (compiled.length === 0)
+        return () => false;
+    return (file) => {
+        const rel = path.relative(cwd, path.resolve(cwd, file)).replace(/\\/g, '/');
+        // Outside cwd entirely — no relative pattern can meaningfully describe it.
+        if (rel.startsWith('../'))
+            return false;
+        const segments = rel.split('/');
+        for (const { re, anchored } of compiled) {
+            if (re.test(rel))
+                return true;
+            if (anchored)
+                continue;
+            // Unanchored: also try every suffix that starts at a segment boundary,
+            // so `generated/` matches `packages/x/generated/y.sql`.
+            for (let i = 1; i < segments.length; i++) {
+                if (re.test(segments.slice(i).join('/')))
+                    return true;
+            }
+        }
+        return false;
+    };
+}
+/** Filter a list of files through {@link makeIgnoreFilter}. */
+export function applyIgnore(files, patterns, cwd) {
+    if (!patterns || patterns.length === 0)
+        return files;
+    const ignored = makeIgnoreFilter(patterns, cwd);
+    return files.filter((f) => !ignored(f));
+}

package/esm/index.js

@@ -10,8 +10,11 @@
  * Rules are injected as values, never discovered by npm name: build a linter
  * with `createLinter({ rules, severity })` and pass your own rules in.
  */
+export { changedFiles, changedSqlFiles, resolveChangedBase } from './changed';
+export { CONFIG_FILENAMES, configDir, findConfigFile, loadLintConfig } from './config';
 export { lintDefinition, severityOf } from './engine';
 export { filesAdapter, lintFiles, lintSource, lintSqlText, resolveSqlFiles, sqlTextAdapter, sqlTextDefinitions } from './file-runner';
+export { applyIgnore, makeIgnoreFilter } from './ignore';
 export { createLinter } from './linter';
 export { parseUnit } from './parse-unit';
 export { LINT_RULES, LINT_RULES_BY_CODE, LINT_RULES_BY_ID, noDynamicSql, noSetSearchPath, noVariableConflict, requireQualifiedRefs } from './rules';

package/esm/linter.js

@@ -17,6 +17,7 @@ export function createLinter(config = {}) {
     const rules = config.rules ?? LINT_RULES;
     const severity = config.severity ?? {};
     const keyword = config.keyword ?? DEFAULT_KEYWORDS;
+    const { ignore, cwd } = config;
     const bind = (options = {}) => ({
         ruleSet: rules,
         severity,
@@ -29,7 +30,7 @@ export function createLinter(config = {}) {
         keyword,
         lintDefinition: (text, language, name, options) => lintDefinition(text, language, name, bind(options)),
         lintSqlText: (source, options) => lintSqlText(source, bind(options)),
-        lintFiles: (paths, options) => lintFiles(paths, bind(options)),
+        lintFiles: (paths, options) => lintFiles(paths, { ...bind(options), ignore, cwd }),
         lintSource: (adapter, options) => lintSource(adapter, bind(options))
     };
 }

package/file-runner.d.ts

@@ -51,14 +51,27 @@ export declare function sqlTextDefinitions(source: string, file?: string): Promi
  * re-anchored to absolute lines within `source`.
  */
 export declare function lintSqlText(source: string, options?: LintOptions): Promise<FileReport>;
+/** File-selection options layered on top of the lint options. */
+export interface FileLintOptions extends LintOptions {
+    /** Glob patterns to exclude (see `makeIgnoreFilter`). */
+    ignore?: string[];
+    /** Directory the `ignore` patterns are relative to (default `process.cwd()`). */
+    cwd?: string;
+}
 /** Resolve a mix of file and directory paths to a sorted list of `.sql` files. */
-export declare function resolveSqlFiles(paths: string[]): Promise<string[]>;
+export declare function resolveSqlFiles(paths: string[], options?: {
+    ignore?: string[];
+    cwd?: string;
+}): Promise<string[]>;
 /** Lint every `.sql` file reachable from `paths` (files or directories). */
-export declare function lintFiles(paths: string[], options?: LintOptions): Promise<FileReport[]>;
+export declare function lintFiles(paths: string[], options?: FileLintOptions): Promise<FileReport[]>;
 /** A {@link SourceAdapter} over an in-memory SQL string. */
 export declare function sqlTextAdapter(source: string, file?: string): SourceAdapter;
 /** A {@link SourceAdapter} over `.sql` files/directories on disk. */
-export declare function filesAdapter(paths: string[]): SourceAdapter;
+export declare function filesAdapter(paths: string[], options?: {
+    ignore?: string[];
+    cwd?: string;
+}): SourceAdapter;
 /**
  * Lint every definition an adapter yields, grouped into one {@link FileReport}
  * per origin file. This is the generic entry point: `@pgsql/lint` ships file

package/file-runner.js

@@ -55,6 +55,7 @@ const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const pgsql_parser_1 = require("pgsql-parser");
 const engine_1 = require("./engine");
+const ignore_1 = require("./ignore");
 const walk_1 = require("./walk");
 /** Count newlines before `offset` — the 0-based line the offset sits on. */
 function lineAtOffset(text, offset) {
@@ -196,7 +197,7 @@ async function sqlFilesUnder(dir) {
     return out;
 }
 /** Resolve a mix of file and directory paths to a sorted list of `.sql` files. */
-async function resolveSqlFiles(paths) {
+async function resolveSqlFiles(paths, options = {}) {
     const files = new Set();
     for (const p of paths) {
         const st = await fs_1.promises.stat(p);
@@ -208,11 +209,11 @@ async function resolveSqlFiles(paths) {
             files.add(p);
         }
     }
-    return [...files].sort();
+    return (0, ignore_1.applyIgnore)([...files].sort(), options.ignore, options.cwd);
 }
 /** Lint every `.sql` file reachable from `paths` (files or directories). */
 async function lintFiles(paths, options = {}) {
-    const files = await resolveSqlFiles(paths);
+    const files = await resolveSqlFiles(paths, { ignore: options.ignore, cwd: options.cwd });
     const reports = [];
     for (const file of files) {
         const source = await fs_1.promises.readFile(file, 'utf8');
@@ -226,11 +227,11 @@ function sqlTextAdapter(source, file) {
     return { id: 'sql-text', definitions: () => sqlTextDefinitions(source, file) };
 }
 /** A {@link SourceAdapter} over `.sql` files/directories on disk. */
-function filesAdapter(paths) {
+function filesAdapter(paths, options = {}) {
     return {
         id: 'files',
         definitions: async () => {
-            const files = await resolveSqlFiles(paths);
+            const files = await resolveSqlFiles(paths, options);
             const out = [];
             for (const file of files) {
                 out.push(...(await sqlTextDefinitions(await fs_1.promises.readFile(file, 'utf8'), file)));

package/ignore.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Path exclusion for the file runner — `--ignore` / `ignore` in a config file.
+ *
+ * Most repositories that lint SQL on disk also *generate* SQL on disk
+ * (packaged modules, introspected schemas, codegen output), and linting
+ * generated output is noise. Patterns are gitignore-flavoured globs matched
+ * against the path relative to `cwd`:
+ *
+ *   - `*` matches within a segment, `**` across segments, `?` one character.
+ *   - A pattern with no glob character matches that path *and everything under
+ *     it*, so `sql/` and `sql` both exclude `sql/app--1.0.0.sql`.
+ *   - An unanchored pattern (no leading `/`) also matches at any segment
+ *     boundary, so `generated/`, `**` patterns, and `*.gen.sql` all work.
+ *   - A leading `/` anchors the pattern to `cwd`.
+ */
+/**
+ * Build a predicate that answers "is this file ignored?". Paths may be
+ * absolute or relative; both are compared as `cwd`-relative POSIX paths.
+ */
+export declare function makeIgnoreFilter(patterns?: string[], cwd?: string): (file: string) => boolean;
+/** Filter a list of files through {@link makeIgnoreFilter}. */
+export declare function applyIgnore(files: string[], patterns?: string[], cwd?: string): string[];

package/ignore.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * Path exclusion for the file runner — `--ignore` / `ignore` in a config file.
+ *
+ * Most repositories that lint SQL on disk also *generate* SQL on disk
+ * (packaged modules, introspected schemas, codegen output), and linting
+ * generated output is noise. Patterns are gitignore-flavoured globs matched
+ * against the path relative to `cwd`:
+ *
+ *   - `*` matches within a segment, `**` across segments, `?` one character.
+ *   - A pattern with no glob character matches that path *and everything under
+ *     it*, so `sql/` and `sql` both exclude `sql/app--1.0.0.sql`.
+ *   - An unanchored pattern (no leading `/`) also matches at any segment
+ *     boundary, so `generated/`, `**` patterns, and `*.gen.sql` all work.
+ *   - A leading `/` anchors the pattern to `cwd`.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeIgnoreFilter = makeIgnoreFilter;
+exports.applyIgnore = applyIgnore;
+const path = __importStar(require("path"));
+/** Turn a glob into a `RegExp` source anchored at both ends. */
+function globToRegExpSource(glob) {
+    let out = '';
+    for (let i = 0; i < glob.length; i++) {
+        const ch = glob[i];
+        if (ch === '*') {
+            if (glob[i + 1] === '*') {
+                // `**/` may match zero segments, so `**/gen/**` also matches `gen/x`.
+                if (glob[i + 2] === '/') {
+                    out += '(?:.*/)?';
+                    i += 2;
+                }
+                else {
+                    out += '.*';
+                    i += 1;
+                }
+            }
+            else {
+                out += '[^/]*';
+            }
+            continue;
+        }
+        if (ch === '?') {
+            out += '[^/]';
+            continue;
+        }
+        out += ch.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    }
+    return out;
+}
+function compile(pattern) {
+    let p = pattern.trim().replace(/\\/g, '/');
+    if (!p || p.startsWith('#'))
+        return null;
+    const anchored = p.startsWith('/');
+    if (anchored)
+        p = p.slice(1);
+    p = p.replace(/^\.\//, '');
+    const dirOnly = p.endsWith('/');
+    if (dirOnly)
+        p = p.replace(/\/+$/, '');
+    if (!p)
+        return null;
+    // A plain path (or an explicit directory) excludes the subtree under it.
+    const source = /[*?]/.test(p) && !dirOnly
+        ? globToRegExpSource(p)
+        : `${globToRegExpSource(p)}(?:/.*)?`;
+    return { re: new RegExp(`^${source}$`), anchored };
+}
+/**
+ * Build a predicate that answers "is this file ignored?". Paths may be
+ * absolute or relative; both are compared as `cwd`-relative POSIX paths.
+ */
+function makeIgnoreFilter(patterns = [], cwd = process.cwd()) {
+    const compiled = patterns.map(compile).filter((c) => c !== null);
+    if (compiled.length === 0)
+        return () => false;
+    return (file) => {
+        const rel = path.relative(cwd, path.resolve(cwd, file)).replace(/\\/g, '/');
+        // Outside cwd entirely — no relative pattern can meaningfully describe it.
+        if (rel.startsWith('../'))
+            return false;
+        const segments = rel.split('/');
+        for (const { re, anchored } of compiled) {
+            if (re.test(rel))
+                return true;
+            if (anchored)
+                continue;
+            // Unanchored: also try every suffix that starts at a segment boundary,
+            // so `generated/` matches `packages/x/generated/y.sql`.
+            for (let i = 1; i < segments.length; i++) {
+                if (re.test(segments.slice(i).join('/')))
+                    return true;
+            }
+        }
+        return false;
+    };
+}
+/** Filter a list of files through {@link makeIgnoreFilter}. */
+function applyIgnore(files, patterns, cwd) {
+    if (!patterns || patterns.length === 0)
+        return files;
+    const ignored = makeIgnoreFilter(patterns, cwd);
+    return files.filter((f) => !ignored(f));
+}

package/index.d.ts

@@ -10,9 +10,14 @@
  * Rules are injected as values, never discovered by npm name: build a linter
  * with `createLinter({ rules, severity })` and pass your own rules in.
  */
+export type { ChangedFilesResult } from './changed';
+export { changedFiles, changedSqlFiles, resolveChangedBase } from './changed';
+export type { LintConfigFile, LoadedLintConfig } from './config';
+export { CONFIG_FILENAMES, configDir, findConfigFile, loadLintConfig } from './config';
 export type { LintOptions } from './engine';
 export { lintDefinition, severityOf } from './engine';
-export { FileFinding, FileReport, filesAdapter, lintFiles, lintSource, lintSqlText, resolveSqlFiles, sqlTextAdapter, sqlTextDefinitions } from './file-runner';
+export { FileFinding, FileLintOptions, FileReport, filesAdapter, lintFiles, lintSource, lintSqlText, resolveSqlFiles, sqlTextAdapter, sqlTextDefinitions } from './file-runner';
+export { applyIgnore, makeIgnoreFilter } from './ignore';
 export type { CallOptions, Linter, LinterConfig } from './linter';
 export { createLinter } from './linter';
 export { parseUnit } from './parse-unit';

package/index.js

@@ -12,7 +12,16 @@
  * with `createLinter({ rules, severity })` and pass your own rules in.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineRule = exports.Suppressions = exports.DEFAULT_KEYWORDS = exports.requireQualifiedRefs = exports.noVariableConflict = exports.noSetSearchPath = exports.noDynamicSql = exports.LINT_RULES_BY_ID = exports.LINT_RULES_BY_CODE = exports.LINT_RULES = exports.parseUnit = exports.createLinter = exports.sqlTextDefinitions = exports.sqlTextAdapter = exports.resolveSqlFiles = exports.lintSqlText = exports.lintSource = exports.lintFiles = exports.filesAdapter = exports.severityOf = exports.lintDefinition = void 0;
+exports.defineRule = exports.Suppressions = exports.DEFAULT_KEYWORDS = exports.requireQualifiedRefs = exports.noVariableConflict = exports.noSetSearchPath = exports.noDynamicSql = exports.LINT_RULES_BY_ID = exports.LINT_RULES_BY_CODE = exports.LINT_RULES = exports.parseUnit = exports.createLinter = exports.makeIgnoreFilter = exports.applyIgnore = exports.sqlTextDefinitions = exports.sqlTextAdapter = exports.resolveSqlFiles = exports.lintSqlText = exports.lintSource = exports.lintFiles = exports.filesAdapter = exports.severityOf = exports.lintDefinition = exports.loadLintConfig = exports.findConfigFile = exports.configDir = exports.CONFIG_FILENAMES = exports.resolveChangedBase = exports.changedSqlFiles = exports.changedFiles = void 0;
+var changed_1 = require("./changed");
+Object.defineProperty(exports, "changedFiles", { enumerable: true, get: function () { return changed_1.changedFiles; } });
+Object.defineProperty(exports, "changedSqlFiles", { enumerable: true, get: function () { return changed_1.changedSqlFiles; } });
+Object.defineProperty(exports, "resolveChangedBase", { enumerable: true, get: function () { return changed_1.resolveChangedBase; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "CONFIG_FILENAMES", { enumerable: true, get: function () { return config_1.CONFIG_FILENAMES; } });
+Object.defineProperty(exports, "configDir", { enumerable: true, get: function () { return config_1.configDir; } });
+Object.defineProperty(exports, "findConfigFile", { enumerable: true, get: function () { return config_1.findConfigFile; } });
+Object.defineProperty(exports, "loadLintConfig", { enumerable: true, get: function () { return config_1.loadLintConfig; } });
 var engine_1 = require("./engine");
 Object.defineProperty(exports, "lintDefinition", { enumerable: true, get: function () { return engine_1.lintDefinition; } });
 Object.defineProperty(exports, "severityOf", { enumerable: true, get: function () { return engine_1.severityOf; } });
@@ -24,6 +33,9 @@ Object.defineProperty(exports, "lintSqlText", { enumerable: true, get: function
 Object.defineProperty(exports, "resolveSqlFiles", { enumerable: true, get: function () { return file_runner_1.resolveSqlFiles; } });
 Object.defineProperty(exports, "sqlTextAdapter", { enumerable: true, get: function () { return file_runner_1.sqlTextAdapter; } });
 Object.defineProperty(exports, "sqlTextDefinitions", { enumerable: true, get: function () { return file_runner_1.sqlTextDefinitions; } });
+var ignore_1 = require("./ignore");
+Object.defineProperty(exports, "applyIgnore", { enumerable: true, get: function () { return ignore_1.applyIgnore; } });
+Object.defineProperty(exports, "makeIgnoreFilter", { enumerable: true, get: function () { return ignore_1.makeIgnoreFilter; } });
 var linter_1 = require("./linter");
 Object.defineProperty(exports, "createLinter", { enumerable: true, get: function () { return linter_1.createLinter; } });
 var parse_unit_1 = require("./parse-unit");

package/linter.d.ts

@@ -19,6 +19,10 @@ export interface LinterConfig {
     severity?: SeverityMap;
     /** Suppression directive keyword(s). Defaults to `['pgsql-lint', 'safegres']`. */
     keyword?: string | string[];
+    /** Glob patterns excluded by the file entry points (`lintFiles`). */
+    ignore?: string[];
+    /** Directory the `ignore` patterns are relative to (default `process.cwd()`). */
+    cwd?: string;
 }
 /** Narrow a single call to a subset of the linter's rules. */
 export type CallOptions = Pick<LintOptions, 'rules'>;

package/linter.js

@@ -23,6 +23,7 @@ function createLinter(config = {}) {
     const rules = config.rules ?? rules_1.LINT_RULES;
     const severity = config.severity ?? {};
     const keyword = config.keyword ?? suppressions_1.DEFAULT_KEYWORDS;
+    const { ignore, cwd } = config;
     const bind = (options = {}) => ({
         ruleSet: rules,
         severity,
@@ -35,7 +36,7 @@ function createLinter(config = {}) {
         keyword,
         lintDefinition: (text, language, name, options) => (0, engine_1.lintDefinition)(text, language, name, bind(options)),
         lintSqlText: (source, options) => (0, file_runner_1.lintSqlText)(source, bind(options)),
-        lintFiles: (paths, options) => (0, file_runner_1.lintFiles)(paths, bind(options)),
+        lintFiles: (paths, options) => (0, file_runner_1.lintFiles)(paths, { ...bind(options), ignore, cwd }),
         lintSource: (adapter, options) => (0, file_runner_1.lintSource)(adapter, bind(options))
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgsql/lint",
-  "version": "18.1.1",
+  "version": "18.2.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "Source-level SQL/PL/pgSQL convention linter: fully-qualified references, no search_path, no dynamic SQL, with ESLint-style inline waivers. Pure AST, no database.",
   "main": "index.js",
@@ -34,15 +34,15 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@pgsql/traverse": "18.7.2",
+    "@pgsql/traverse": "18.7.3",
     "chalk": "^4.1.0",
-    "libpg-query": "18.1.2",
+    "libpg-query": "18.1.4",
     "minimist": "1.2.8",
-    "pgsql-parser": "18.2.2"
+    "pgsql-parser": "18.2.3"
   },
   "devDependencies": {
     "@types/minimist": "^1.2.5",
-    "makage": "^0.1.8"
+    "makage": "^0.5.1"
   },
   "keywords": [
     "sql",
@@ -56,5 +56,5 @@
     "search_path",
     "dynamic-sql"
   ],
-  "gitHead": "bc21e590439743a236da9757adf2d43d34432710"
+  "gitHead": "fa4ea3167cadd5eb0e9a216a2abfa564f6c62364"
 }