locksmith-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Christopher King
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,151 @@
+# Locksmith 🔒
+
+**An MCP server that catches dangerous SQL migrations before they lock your database.**
+
+Most migrations look harmless and then take down production: a plain `CREATE INDEX`
+blocks every write for the length of the build; `ALTER COLUMN ... TYPE` rewrites the
+whole table under `ACCESS EXCLUSIVE`; `SET NOT NULL` scans every row. Which operations
+are safe — and the rewrite that makes the dangerous ones safe — is knowledge that
+lives in senior engineers' heads.
+
+Locksmith encodes that knowledge as a tool an LLM agent (or a human) can call. Give it
+a PostgreSQL migration; it returns a **PASS / REVIEW / BLOCK** verdict, a finding for
+each risky statement (which lock it takes, *why* that's dangerous), and a concrete safe
+rewrite.
+
+```
+🛑 BLOCK — do not ship as written
+
+## 🛑 CREATE INDEX without CONCURRENTLY  `create-index-non-concurrent` (line 5)
+> `CREATE INDEX idx_users_email ON users (email)`
+Problem: This index build will block all writes to the table until it completes.
+Lock taken: SHARE (blocks writes)
+Fix: Build the index with CREATE INDEX CONCURRENTLY, which does not block writes.
+Suggested rewrite:
+  CREATE INDEX CONCURRENTLY idx_users_email ON users (email)
+```
+
+## Why an MCP server?
+
+An agent can often reason about lock semantics — but not *reproducibly*, and not in a
+way you can test, audit, or trust to gate a deploy unsupervised. The same prompt may
+approve a table-rewriting `ALTER` one run and flag it the next, or miss it entirely in a
+long migration. Locksmith turns that probabilistic capability into a **deterministic,
+tested** tool: the lock semantics were verified once (against the PostgreSQL docs and the
+parser's real behavior, with a test suite pinning each rule) and now run identically every
+time, returning the same verdict plus a paste-ready fix — so "review this migration" stops
+being a guess.
+
+## Capabilities
+
+**Tools**
+- `analyze_migration(sql, assumeLargeTables?)` → verdict + findings + safe rewrites
+  (both human-readable Markdown and validated structured output).
+- `explain_lock(query)` → what a given Postgres lock mode blocks and what takes it.
+
+**Resources**
+- `locksmith://lock-matrix` — the PostgreSQL table-level lock compatibility matrix.
+- `locksmith://rules` — the full rule catalog (id, severity, rationale) as JSON.
+
+**Prompts**
+- `review-migration` — analyze a migration and summarize the risk as a PR comment.
+
+## Rule catalog
+
+| Rule | Severity | What it catches |
+|------|----------|-----------------|
+| `create-index-non-concurrent` | critical | `CREATE INDEX` without `CONCURRENTLY` (blocks writes) |
+| `index-concurrently-in-transaction` | critical | `CONCURRENTLY` inside `BEGIN/COMMIT` (Postgres rejects it) |
+| `add-column-not-null-no-default` | critical | `ADD COLUMN NOT NULL` with no default (fails / rewrites) |
+| `alter-column-type` | critical | `ALTER COLUMN ... TYPE` (full table rewrite) |
+| `add-column-volatile-default` | warning | `ADD COLUMN ... DEFAULT now()` etc. (rewrites table) |
+| `set-not-null` | warning | `SET NOT NULL` (full scan under exclusive lock) |
+| `add-foreign-key-validating` | warning | `ADD FOREIGN KEY` without `NOT VALID` (locks both tables) |
+| `add-check-constraint-no-not-valid` | warning | `ADD CHECK` without `NOT VALID` (full scan) |
+| `drop-column-or-table` | warning | destructive + breaks deployed code |
+| `rename-column-or-table` | warning | breaks running app code |
+
+### Suppressing a rule
+
+Acknowledge a deliberate risk inline, eslint-style:
+
+```sql
+-- locksmith:disable create-index-non-concurrent
+CREATE INDEX idx_users_email ON users (email);
+```
+
+A bare `-- locksmith:disable` suppresses all rules for the next statement.
+
+## Install & run
+
+No clone or build required — run it straight from npm:
+
+```bash
+npx locksmith-mcp
+```
+
+### Use with Claude Code
+
+```bash
+claude mcp add locksmith -- npx -y locksmith-mcp
+```
+
+Or add to any MCP client config (Claude Desktop, etc.):
+
+```json
+{
+  "mcpServers": {
+    "locksmith": { "command": "npx", "args": ["-y", "locksmith-mcp"] }
+  }
+}
+```
+
+### Run from source instead
+
+```bash
+git clone https://github.com/cxk280/locksmith.git && cd locksmith
+npm install && npm run build
+# then point your client at:  node /absolute/path/to/locksmith/dist/index.js
+```
+
+### Try it with the MCP Inspector
+
+```bash
+npx @modelcontextprotocol/inspector npx -y locksmith-mcp
+```
+
+Then call `analyze_migration` with the contents of `examples/dangerous.sql`.
+
+## Development
+
+```bash
+npm run dev    # run from source with tsx
+npm test       # vitest: per-rule + golden tests on examples/
+```
+
+## Design notes
+
+- **Deterministic.** No clock, randomness, or network — same SQL in, same verdict out.
+  That's what makes it testable and safe to drop into CI.
+- **Hybrid parsing.** Statements are parsed to an AST ([`pgsql-ast-parser`]) when the
+  parser supports them; rules fall back to normalized text for Postgres clauses the
+  parser doesn't model (`NOT VALID`, `CONCURRENTLY`). An unparseable statement degrades
+  to a "review manually" note — the linter never fails closed on input it doesn't
+  understand.
+- **Composable rules.** Each rule is a pure function with its own metadata in its own
+  file; adding one is a one-file change plus a line in the registry.
+- **Advisory, not a prover.** Locksmith complements review; `assumeLargeTables` defaults
+  to `true` so it errs toward flagging.
+
+## Roadmap
+
+- Remote (Streamable HTTP) transport for hosted deployments.
+- Additional dialects (MySQL, SQLite).
+- Optional live DB introspection to suppress findings on known-small tables.
+- A GitHub Action wrapping the same engine to gate PRs.
+
+[`pgsql-ast-parser`]: https://github.com/oguimbal/pgsql-ast-parser
+
+## License
+
+MIT

package/dist/analyzer/astUtils.d.ts

@@ -0,0 +1,19 @@
+import type { Stmt } from "./types.js";
+/**
+ * The pgsql-ast-parser type union is large and version-sensitive. Rules only
+ * need a few fields, so we traverse with small, defensively-typed helpers
+ * rather than importing the full node types. `any` is intentional and local.
+ */
+export type AnyAst = any;
+export declare function astType(stmt: Stmt): string | undefined;
+/** Extract a plain name from the parser's `{ name }` / string shapes. */
+export declare function nameOf(x: AnyAst): string | undefined;
+export declare function tableName(ast: AnyAst): string | undefined;
+/** The list of changes inside an ALTER TABLE, or [] for anything else. */
+export declare function alterChanges(ast: AnyAst): AnyAst[];
+/**
+ * Is an ADD COLUMN default a compile-time constant? Constant defaults are
+ * cheap on PG11+ (stored as metadata); volatile defaults like now() force a
+ * full table rewrite.
+ */
+export declare function isConstantDefault(defaultExpr: AnyAst): boolean;

package/dist/analyzer/astUtils.js

@@ -0,0 +1,50 @@
+export function astType(stmt) {
+    return stmt.ast?.type;
+}
+/** Extract a plain name from the parser's `{ name }` / string shapes. */
+export function nameOf(x) {
+    if (x == null)
+        return undefined;
+    if (typeof x === "string")
+        return x;
+    if (typeof x.name === "string")
+        return x.name;
+    if (x.name && typeof x.name.name === "string")
+        return x.name.name;
+    return undefined;
+}
+export function tableName(ast) {
+    return nameOf(ast?.table) ?? nameOf(ast?.name);
+}
+/** The list of changes inside an ALTER TABLE, or [] for anything else. */
+export function alterChanges(ast) {
+    if (ast?.type !== "alter table")
+        return [];
+    const c = ast.changes;
+    if (Array.isArray(c))
+        return c;
+    return c ? [c] : [];
+}
+const LITERAL_DEFAULT_TYPES = new Set([
+    "integer",
+    "numeric",
+    "string",
+    "boolean",
+    "null",
+    "constant",
+]);
+/**
+ * Is an ADD COLUMN default a compile-time constant? Constant defaults are
+ * cheap on PG11+ (stored as metadata); volatile defaults like now() force a
+ * full table rewrite.
+ */
+export function isConstantDefault(defaultExpr) {
+    if (defaultExpr == null)
+        return false;
+    // Negative literals parse as a unary op around a literal — still constant.
+    if (defaultExpr.type === "unary" && defaultExpr.operand) {
+        return isConstantDefault(defaultExpr.operand);
+    }
+    return LITERAL_DEFAULT_TYPES.has(defaultExpr.type);
+}
+//# sourceMappingURL=astUtils.js.map

package/dist/analyzer/astUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"astUtils.js","sourceRoot":"","sources":["../../src/analyzer/astUtils.ts"],"names":[],"mappings":"AASA,MAAM,UAAU,OAAO,CAAC,IAAU;IAChC,OAAQ,IAAI,CAAC,GAAc,EAAE,IAAI,CAAC;AACpC,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,MAAM,CAAC,CAAS;IAC9B,IAAI,CAAC,IAAI,IAAI;QAAE,OAAO,SAAS,CAAC;IAChC,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,CAAC,CAAC;IACpC,IAAI,OAAO,CAAC,CAAC,IAAI,KAAK,QAAQ;QAAE,OAAO,CAAC,CAAC,IAAI,CAAC;IAC9C,IAAI,CAAC,CAAC,IAAI,IAAI,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,QAAQ;QAAE,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;IAClE,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,GAAW;IACnC,OAAO,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AACjD,CAAC;AAED,0EAA0E;AAC1E,MAAM,UAAU,YAAY,CAAC,GAAW;IACtC,IAAI,GAAG,EAAE,IAAI,KAAK,aAAa;QAAE,OAAO,EAAE,CAAC;IAC3C,MAAM,CAAC,GAAG,GAAG,CAAC,OAAO,CAAC;IACtB,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AACtB,CAAC;AAED,MAAM,qBAAqB,GAAG,IAAI,GAAG,CAAC;IACpC,SAAS;IACT,SAAS;IACT,QAAQ;IACR,SAAS;IACT,MAAM;IACN,UAAU;CACX,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,WAAmB;IACnD,IAAI,WAAW,IAAI,IAAI;QAAE,OAAO,KAAK,CAAC;IACtC,2EAA2E;IAC3E,IAAI,WAAW,CAAC,IAAI,KAAK,OAAO,IAAI,WAAW,CAAC,OAAO,EAAE,CAAC;QACxD,OAAO,iBAAiB,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IAChD,CAAC;IACD,OAAO,qBAAqB,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;AACrD,CAAC"}

package/dist/analyzer/engine.d.ts

@@ -0,0 +1,11 @@
+import type { AnalysisResult } from "./types.js";
+export interface AnalyzeOptions {
+    /** Treat target tables as large/hot (default true → fail safe). */
+    assumeLargeTables?: boolean;
+}
+/**
+ * Analyze a migration script and produce a verdict + findings. Pure and
+ * deterministic: same SQL in, same result out — no clock, no randomness, no
+ * network. That's what makes it trivially testable and safe to run in CI.
+ */
+export declare function analyzeMigration(sql: string, opts?: AnalyzeOptions): AnalysisResult;

package/dist/analyzer/engine.js

@@ -0,0 +1,87 @@
+import { parseMigration } from "./parse.js";
+import { parseDirectives, isSuppressed } from "./suppress.js";
+import { rules } from "./rules/index.js";
+import { computeVerdict, summarize } from "./verdict.js";
+const TXN_BEGIN = /^(begin|start\s+transaction)\b/i;
+const TXN_END = /^(commit|end|rollback)\b/i;
+/**
+ * Analyze a migration script and produce a verdict + findings. Pure and
+ * deterministic: same SQL in, same result out — no clock, no randomness, no
+ * network. That's what makes it trivially testable and safe to run in CI.
+ */
+export function analyzeMigration(sql, opts = {}) {
+    const assumeLargeTables = opts.assumeLargeTables ?? true;
+    const statements = parseMigration(sql);
+    const directives = parseDirectives(sql);
+    const findings = [];
+    let suppressed = 0;
+    let unparsed = 0;
+    let inTxn = false;
+    let prevEndLine = 0;
+    for (const stmt of statements) {
+        if (stmt.ast === null)
+            unparsed++;
+        const ctx = { assumeLargeTables, inExplicitTransaction: inTxn };
+        for (const rule of rules) {
+            const hit = safeCheck(rule.id, () => rule.check(stmt, ctx));
+            if (!hit)
+                continue;
+            // A directive on the statement or in its leading comment block suppresses it.
+            if (isSuppressed(rule.id, directives, prevEndLine + 1, stmt.endLine)) {
+                suppressed++;
+                continue;
+            }
+            findings.push({
+                ruleId: rule.id,
+                title: rule.title,
+                severity: rule.severity,
+                line: stmt.startLine,
+                statement: truncate(stmt.normalized),
+                lockTaken: hit.lockTaken,
+                message: hit.message,
+                rationale: rule.rationale,
+                remediation: rule.remediation,
+                suggestedRewrite: hit.suggestedRewrite,
+                docsUrl: rule.docsUrl,
+            });
+        }
+        // Update transaction state for the *next* statement.
+        if (TXN_BEGIN.test(stmt.lower))
+            inTxn = true;
+        else if (TXN_END.test(stmt.lower))
+            inTxn = false;
+        prevEndLine = stmt.endLine;
+    }
+    // Stable, predictable ordering: by line, then severity (critical first).
+    const sevRank = { critical: 0, warning: 1, info: 2 };
+    findings.sort((a, b) => a.line - b.line || sevRank[a.severity] - sevRank[b.severity]);
+    const verdict = computeVerdict(findings);
+    return {
+        verdict,
+        summary: summarize(verdict, findings),
+        stats: {
+            statements: statements.length,
+            findings: findings.length,
+            critical: findings.filter((f) => f.severity === "critical").length,
+            warning: findings.filter((f) => f.severity === "warning").length,
+            info: findings.filter((f) => f.severity === "info").length,
+            suppressed,
+            unparsed,
+        },
+        findings,
+    };
+}
+/** A buggy rule must never crash the whole analysis. */
+function safeCheck(ruleId, fn) {
+    try {
+        return fn();
+    }
+    catch (err) {
+        process.stderr.write(`[locksmith] rule "${ruleId}" threw: ${String(err)}\n`);
+        return null;
+    }
+}
+function truncate(s, max = 200) {
+    return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+}
+//# sourceMappingURL=engine.js.map

package/dist/analyzer/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","sourceRoot":"","sources":["../../src/analyzer/engine.ts"],"names":[],"mappings":"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"}

package/dist/analyzer/parse.d.ts

@@ -0,0 +1,7 @@
+import type { Stmt } from "./types.js";
+/**
+ * Split a migration script into Stmt records. Each statement is parsed
+ * individually so a single unsupported statement degrades to `ast: null`
+ * (still text-scannable by rules) instead of failing the whole file.
+ */
+export declare function parseMigration(sql: string): Stmt[];

package/dist/analyzer/parse.js

@@ -0,0 +1,165 @@
+import { parse } from "pgsql-ast-parser";
+function splitStatements(sql) {
+    const out = [];
+    let buf = ""; // raw chars of the current statement
+    let stripped = ""; // same, minus comments
+    let line = 1;
+    let startLine = 1;
+    let started = false;
+    let i = 0;
+    const n = sql.length;
+    const pushStatement = (endLine) => {
+        const raw = buf.trim();
+        if (raw.length > 0) {
+            out.push({
+                raw,
+                stripped: stripped.replace(/\s+/g, " ").trim(),
+                startLine,
+                endLine,
+            });
+        }
+        buf = "";
+        stripped = "";
+        started = false;
+    };
+    while (i < n) {
+        const ch = sql[i];
+        const next = sql[i + 1];
+        // Track the line where the next statement's content begins.
+        if (!started && !/\s/.test(ch)) {
+            started = true;
+            startLine = line;
+        }
+        // -- line comment
+        if (ch === "-" && next === "-") {
+            buf += "--";
+            i += 2;
+            while (i < n && sql[i] !== "\n") {
+                buf += sql[i];
+                i++;
+            }
+            continue;
+        }
+        // /* block comment */ (Postgres allows nesting)
+        if (ch === "/" && next === "*") {
+            let depth = 1;
+            buf += "/*";
+            i += 2;
+            while (i < n && depth > 0) {
+                if (sql[i] === "/" && sql[i + 1] === "*") {
+                    depth++;
+                    buf += "/*";
+                    i += 2;
+                }
+                else if (sql[i] === "*" && sql[i + 1] === "/") {
+                    depth--;
+                    buf += "*/";
+                    i += 2;
+                }
+                else {
+                    if (sql[i] === "\n")
+                        line++;
+                    buf += sql[i];
+                    i++;
+                }
+            }
+            continue;
+        }
+        // '...' string literal (doubled '' escapes)
+        if (ch === "'") {
+            buf += ch;
+            stripped += ch;
+            i++;
+            while (i < n) {
+                if (sql[i] === "'" && sql[i + 1] === "'") {
+                    buf += "''";
+                    stripped += "''";
+                    i += 2;
+                    continue;
+                }
+                if (sql[i] === "\n")
+                    line++;
+                buf += sql[i];
+                stripped += sql[i];
+                if (sql[i] === "'") {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            continue;
+        }
+        // $tag$ dollar-quoted string $tag$
+        const dollar = matchDollarTag(sql, i);
+        if (dollar) {
+            const tag = dollar;
+            buf += tag;
+            stripped += tag;
+            i += tag.length;
+            // consume until the same tag closes the literal
+            while (i < n) {
+                if (sql.startsWith(tag, i)) {
+                    buf += tag;
+                    stripped += tag;
+                    i += tag.length;
+                    break;
+                }
+                if (sql[i] === "\n")
+                    line++;
+                buf += sql[i];
+                stripped += sql[i];
+                i++;
+            }
+            continue;
+        }
+        if (ch === ";") {
+            buf += ch;
+            pushStatement(line);
+            i++;
+            continue;
+        }
+        if (ch === "\n")
+            line++;
+        buf += ch;
+        stripped += ch;
+        i++;
+    }
+    // trailing statement without a closing semicolon
+    pushStatement(line);
+    return out;
+}
+/** If position `i` begins a `$tag$` dollar-quote opener, return that opener. */
+function matchDollarTag(sql, i) {
+    if (sql[i] !== "$")
+        return null;
+    const m = /^\$[A-Za-z_]?[A-Za-z0-9_]*\$/.exec(sql.slice(i));
+    return m ? m[0] : null;
+}
+/**
+ * Split a migration script into Stmt records. Each statement is parsed
+ * individually so a single unsupported statement degrades to `ast: null`
+ * (still text-scannable by rules) instead of failing the whole file.
+ */
+export function parseMigration(sql) {
+    return splitStatements(sql).map((s) => {
+        let ast = null;
+        let parseError;
+        try {
+            const parsed = parse(s.raw);
+            ast = parsed.length > 0 ? parsed[0] : null;
+        }
+        catch (err) {
+            parseError = err instanceof Error ? err.message.split("\n")[0] : String(err);
+        }
+        return {
+            raw: s.raw,
+            normalized: s.stripped,
+            lower: s.stripped.toLowerCase(),
+            startLine: s.startLine,
+            endLine: s.endLine,
+            ast,
+            parseError,
+        };
+    });
+}
+//# sourceMappingURL=parse.js.map

package/dist/analyzer/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","sourceRoot":"","sources":["../../src/analyzer/parse.ts"],"names":[],"mappings":"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"}

package/dist/analyzer/rules/addCheckConstraintNoNotValid.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types.js";
+export declare const addCheckConstraintNoNotValid: Rule;

package/dist/analyzer/rules/addCheckConstraintNoNotValid.js

@@ -0,0 +1,24 @@
+const CHECK_RE = /\badd\s+(?:constraint\s+\S+\s+)?check\s*\(/i;
+export const addCheckConstraintNoNotValid = {
+    id: "add-check-constraint-no-not-valid",
+    title: "ADD CHECK constraint validates immediately",
+    severity: "warning",
+    rationale: "Adding a CHECK constraint scans every existing row to validate it while holding ACCESS EXCLUSIVE on the table, blocking reads and writes during the scan.",
+    remediation: "Add the constraint NOT VALID (instant — applies to new/changed rows), then VALIDATE CONSTRAINT separately to scan existing rows without blocking writes.",
+    docsUrl: "https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-DESC-ADD-TABLE-CONSTRAINT",
+    check(stmt) {
+        if (!stmt.lower.startsWith("alter table"))
+            return null;
+        if (!CHECK_RE.test(stmt.lower))
+            return null;
+        if (/\bnot\s+valid\b/i.test(stmt.lower))
+            return null;
+        const withNotValid = stmt.normalized.replace(/;?\s*$/, " NOT VALID;");
+        return {
+            message: "This CHECK constraint is validated immediately, scanning the table under a lock.",
+            lockTaken: "ACCESS EXCLUSIVE",
+            suggestedRewrite: `${withNotValid}\n-- then, separately:\n-- ALTER TABLE <table> VALIDATE CONSTRAINT <name>;`,
+        };
+    },
+};
+//# sourceMappingURL=addCheckConstraintNoNotValid.js.map

package/dist/analyzer/rules/addCheckConstraintNoNotValid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"addCheckConstraintNoNotValid.js","sourceRoot":"","sources":["../../../src/analyzer/rules/addCheckConstraintNoNotValid.ts"],"names":[],"mappings":"AAEA,MAAM,QAAQ,GAAG,6CAA6C,CAAC;AAE/D,MAAM,CAAC,MAAM,4BAA4B,GAAS;IAChD,EAAE,EAAE,mCAAmC;IACvC,KAAK,EAAE,4CAA4C;IACnD,QAAQ,EAAE,SAAS;IACnB,SAAS,EACP,2JAA2J;IAC7J,WAAW,EACT,0JAA0J;IAC5J,OAAO,EAAE,sGAAsG;IAC/G,KAAK,CAAC,IAAI;QACR,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC;YAAE,OAAO,IAAI,CAAC;QACvD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAC5C,IAAI,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAErD,MAAM,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;QACtE,OAAO;YACL,OAAO,EAAE,kFAAkF;YAC3F,SAAS,EAAE,kBAAkB;YAC7B,gBAAgB,EAAE,GAAG,YAAY,4EAA4E;SAC9G,CAAC;IACJ,CAAC;CACF,CAAC"}

package/dist/analyzer/rules/addColumnNotNullNoDefault.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types.js";
+export declare const addColumnNotNullNoDefault: Rule;

package/dist/analyzer/rules/addColumnNotNullNoDefault.js

@@ -0,0 +1,42 @@
+import { alterChanges, tableName, nameOf } from "../astUtils.js";
+function constraintTypes(change) {
+    const cons = change?.column?.constraints;
+    return Array.isArray(cons) ? cons.map((c) => c?.type) : [];
+}
+export const addColumnNotNullNoDefault = {
+    id: "add-column-not-null-no-default",
+    title: "ADD COLUMN NOT NULL without a default",
+    severity: "critical",
+    rationale: "Adding a NOT NULL column without a default fails outright on a non-empty table (existing rows would violate NOT NULL), and even when it succeeds it takes ACCESS EXCLUSIVE on the table.",
+    remediation: "Add the column nullable, backfill existing rows, then add the NOT NULL constraint via a validated CHECK — in separate steps.",
+    docsUrl: "https://www.postgresql.org/docs/current/sql-altertable.html",
+    check(stmt) {
+        const changes = alterChanges(stmt.ast);
+        for (const change of changes) {
+            if (change?.type !== "add column")
+                continue;
+            const types = constraintTypes(change);
+            const hasNotNull = types.includes("not null");
+            const hasDefault = types.includes("default");
+            if (hasNotNull && !hasDefault) {
+                const table = tableName(stmt.ast) ?? "your_table";
+                const col = nameOf(change.column) ?? nameOf(change.column?.name) ?? "new_col";
+                return {
+                    message: `Column "${col}" is added NOT NULL with no default; this fails on any non-empty table and rewrites it otherwise.`,
+                    lockTaken: "ACCESS EXCLUSIVE",
+                    suggestedRewrite: [
+                        `-- Step 1: add nullable`,
+                        `ALTER TABLE ${table} ADD COLUMN ${col} <type>;`,
+                        `-- Step 2: backfill in batches (outside this migration if the table is large)`,
+                        `UPDATE ${table} SET ${col} = <value> WHERE ${col} IS NULL;`,
+                        `-- Step 3: enforce NOT NULL without a long scan`,
+                        `ALTER TABLE ${table} ADD CONSTRAINT ${col}_not_null CHECK (${col} IS NOT NULL) NOT VALID;`,
+                        `ALTER TABLE ${table} VALIDATE CONSTRAINT ${col}_not_null;`,
+                    ].join("\n"),
+                };
+            }
+        }
+        return null;
+    },
+};
+//# sourceMappingURL=addColumnNotNullNoDefault.js.map

package/dist/analyzer/rules/addColumnNotNullNoDefault.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"addColumnNotNullNoDefault.js","sourceRoot":"","sources":["../../../src/analyzer/rules/addColumnNotNullNoDefault.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAU,MAAM,gBAAgB,CAAC;AAEzE,SAAS,eAAe,CAAC,MAAc;IACrC,MAAM,IAAI,GAAG,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC;IACzC,OAAO,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AACrE,CAAC;AAED,MAAM,CAAC,MAAM,yBAAyB,GAAS;IAC7C,EAAE,EAAE,gCAAgC;IACpC,KAAK,EAAE,uCAAuC;IAC9C,QAAQ,EAAE,UAAU;IACpB,SAAS,EACP,0LAA0L;IAC5L,WAAW,EACT,8HAA8H;IAChI,OAAO,EAAE,6DAA6D;IACtE,KAAK,CAAC,IAAI;QACR,MAAM,OAAO,GAAG,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACvC,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,IAAI,MAAM,EAAE,IAAI,KAAK,YAAY;gBAAE,SAAS;YAC5C,MAAM,KAAK,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC;YACtC,MAAM,UAAU,GAAG,KAAK,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;YAC9C,MAAM,UAAU,GAAG,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;YAC7C,IAAI,UAAU,IAAI,CAAC,UAAU,EAAE,CAAC;gBAC9B,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,YAAY,CAAC;gBAClD,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,SAAS,CAAC;gBAC9E,OAAO;oBACL,OAAO,EAAE,WAAW,GAAG,mGAAmG;oBAC1H,SAAS,EAAE,kBAAkB;oBAC7B,gBAAgB,EAAE;wBAChB,yBAAyB;wBACzB,eAAe,KAAK,eAAe,GAAG,UAAU;wBAChD,+EAA+E;wBAC/E,UAAU,KAAK,QAAQ,GAAG,oBAAoB,GAAG,WAAW;wBAC5D,iDAAiD;wBACjD,eAAe,KAAK,mBAAmB,GAAG,oBAAoB,GAAG,0BAA0B;wBAC3F,eAAe,KAAK,wBAAwB,GAAG,YAAY;qBAC5D,CAAC,IAAI,CAAC,IAAI,CAAC;iBACb,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF,CAAC"}

package/dist/analyzer/rules/addColumnVolatileDefault.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types.js";
+export declare const addColumnVolatileDefault: Rule;