@bolvrk/engine-sqlite 0.1.4

package/src/parser.ts

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+/**
+ * SQLite parse layer: sql-parser-cst (MIT, pure TypeScript, a real
+ * dialect-aware grammar with source ranges). The only place SQLite SQL is
+ * turned into structure — rules walk the CST, never regex over SQL. Anything
+ * the grammar rejects fails the whole check: a partial check could hide a
+ * danger, so the engine reports "not checked" rather than guessing.
+ */
+import { parse, type Node, type Program, type Statement } from "sql-parser-cst";
+
+export type { Node, Statement };
+
+export class SqliteMigrationParseError extends Error {
+  constructor(message: string, public readonly cause?: unknown) {
+    super(message);
+    this.name = "SqliteMigrationParseError";
+  }
+}
+
+export interface ParsedSqliteStatement {
+  /** 0-based position in the migration file (empty statements — a stray `;` — are skipped). */
+  index: number;
+  /** CST node type, e.g. "alter_table_stmt", "pragma_stmt". */
+  type: Statement["type"];
+  /** The statement node; rules descend from here. */
+  node: Statement;
+  /** Verbatim SQL text of this statement, trimmed. */
+  sql: string;
+  /** Character offset of the statement's start in the migration text. */
+  location: number;
+  /** Character offset one past the statement's end. */
+  end: number;
+}
+
+export interface ParsedSqliteMigration {
+  statements: ParsedSqliteStatement[];
+  /** sql-parser-cst version the tree came from. */
+  parserVersion: string;
+}
+
+import packageJson from "../package.json";
+const PARSER_VERSION: string = packageJson.dependencies["sql-parser-cst"];
+
+export function parseSqliteMigration(sql: string): ParsedSqliteMigration {
+  let program: Program;
+  try {
+    program = parse(sql, { dialect: "sqlite", includeRange: true });
+  } catch (err: any) {
+    const message = String(err?.message ?? err).split("\n")[0];
+    throw new SqliteMigrationParseError(`Migration is not valid SQLite SQL: ${message}`, err);
+  }
+  const statements: ParsedSqliteStatement[] = [];
+  for (const node of program.statements) {
+    if (node.type === "empty") continue;
+    const [start, stop] = node.range ?? [0, sql.length];
+    // Ranges are inclusive of the last token character.
+    const end = Math.min(stop + 1, sql.length);
+    statements.push({
+      index: statements.length,
+      type: node.type,
+      node,
+      sql: sql.slice(start, end).trim(),
+      location: start,
+      end,
+    });
+  }
+  return { statements, parserVersion: PARSER_VERSION };
+}

package/src/rule.ts

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+/**
+ * SL rule interface — the same shape as the Postgres engine's Rule
+ * (packages/engine/src/rule.ts) over the SQLite parse tree. Deliberately NOT
+ * shared code: the only shared abstractions between engines are the findings
+ * contract, the RuleMeta shape and the severity taxonomy.
+ */
+import type { Finding, RuleMeta } from "@bolvrk/engine";
+import type { ParsedSqliteMigration, ParsedSqliteStatement } from "./parser";
+
+export interface SlRuleContext {
+  migration: ParsedSqliteMigration;
+}
+
+export interface SlRule {
+  meta: RuleMeta;
+  check(ctx: SlRuleContext): Finding[];
+}
+
+/** Helper for building a finding with the rule's identity filled in. */
+export function finding(
+  rule: SlRule,
+  stmt: ParsedSqliteStatement,
+  props: Omit<Finding, "ruleId" | "ruleVersion" | "tier" | "statementIndex" | "sql" | "severity"> &
+    Partial<Pick<Finding, "severity">>,
+): Finding {
+  return {
+    ruleId: rule.meta.id,
+    ruleVersion: rule.meta.version,
+    tier: rule.meta.tier,
+    severity: props.severity ?? rule.meta.defaultSeverity,
+    statementIndex: stmt.index,
+    sql: stmt.sql,
+    ...props,
+  };
+}

package/src/rules/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/src/rules/add-column.ts

@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * ALTER TABLE ADD COLUMN forms SQLite refuses or scans for. The manual lists
+ * every restriction in one paragraph; each is its own rule so a finding says
+ * exactly which one the statement hit.
+ */
+import type { Finding } from "@bolvrk/engine";
+import { addedColumns, constraintOf, nameOf, tableCreatedInMigration, tableOf } from "../helpers";
+import { sl001Meta, sl002Meta, sl003Meta, sl004Meta, sl005Meta, sl008Meta } from "../metas/index";
+import { finding, type SlRule, type SlRuleContext } from "../rule";
+
+type AnyNode = Record<string, any>;
+
+/** Every ADD COLUMN in the migration with its statement and target table; new tables excluded (a column added to a table created in the same file has no rows to hurt). */
+function eachAddedColumn(ctx: SlRuleContext, visit: (stmt: SlRuleContext["migration"]["statements"][number], table: string, column: AnyNode) => void): void {
+  for (const stmt of ctx.migration.statements) {
+    const columns = addedColumns(stmt);
+    if (columns.length === 0) continue;
+    const table = tableOf(stmt) ?? "";
+    if (table && tableCreatedInMigration(ctx.migration, stmt.index, table)) continue;
+    for (const column of columns) visit(stmt, table, column);
+  }
+}
+
+function isNullDefault(column: AnyNode): boolean {
+  const def = constraintOf(column, "constraint_default");
+  return !def || def.expr?.type === "null_literal" || def.constraint?.expr?.type === "null_literal";
+}
+
+/** SL001: NOT NULL with no default (or DEFAULT NULL) — the statement fails. */
+export const sl001: SlRule = {
+  meta: sl001Meta,
+  check(ctx) {
+    const out: Finding[] = [];
+    eachAddedColumn(ctx, (stmt, table, column) => {
+      if (!constraintOf(column, "constraint_not_null")) return;
+      // A generated column is computed, never NULL by omission — the NOT NULL restriction does not apply to it.
+      if (constraintOf(column, "constraint_generated")) return;
+      if (!isNullDefault(column)) return;
+      const name = nameOf(column.name);
+      out.push(
+        finding(sl001, stmt, {
+          title: `ADD COLUMN "${name}" NOT NULL has no default — SQLite refuses it`,
+          message:
+            `SQLite cannot fill existing rows of "${table}" with NULL for a NOT NULL column, so the statement fails: "Cannot add a NOT NULL column with default value NULL". ` +
+            `Add a non-NULL DEFAULT (schema-only, no rewrite), or add the column nullable and enforce NOT NULL in a later rebuild.`,
+          object: { table, column: name },
+        }),
+      );
+    });
+    return out;
+  },
+};
+
+/** SL002: PRIMARY KEY or UNIQUE on an added column — the statement fails. */
+export const sl002: SlRule = {
+  meta: sl002Meta,
+  check(ctx) {
+    const out: Finding[] = [];
+    eachAddedColumn(ctx, (stmt, table, column) => {
+      const kind = constraintOf(column, "constraint_primary_key") ? "PRIMARY KEY" : constraintOf(column, "constraint_unique") ? "UNIQUE" : undefined;
+      if (!kind) return;
+      const name = nameOf(column.name);
+      out.push(
+        finding(sl002, stmt, {
+          title: `ADD COLUMN "${name}" ${kind} is rejected by SQLite`,
+          message:
+            `ALTER TABLE ADD COLUMN may not carry a ${kind} constraint; SQLite fails the statement and "${table}" is unchanged. ` +
+            (kind === "UNIQUE"
+              ? `Add the column plain and CREATE UNIQUE INDEX as its own statement.`
+              : `A new primary key needs the table rebuilt (create, copy, drop, rename).`),
+          object: { table, column: name },
+        }),
+      );
+    });
+    return out;
+  },
+};
+
+const NON_CONSTANT_DEFAULTS = new Set(["CURRENT_TIME", "CURRENT_DATE", "CURRENT_TIMESTAMP"]);
+
+/** SL003: DEFAULT CURRENT_* or a parenthesised expression — the statement fails. */
+export const sl003: SlRule = {
+  meta: sl003Meta,
+  check(ctx) {
+    const out: Finding[] = [];
+    eachAddedColumn(ctx, (stmt, table, column) => {
+      const def = constraintOf(column, "constraint_default");
+      const expr = def?.expr ?? def?.constraint?.expr;
+      if (!expr) return;
+      const isCurrent = expr.type === "func_call" && NON_CONSTANT_DEFAULTS.has(String(nameOf(expr.name) ?? "").toUpperCase());
+      const isExpression = expr.type === "paren_expr";
+      if (!isCurrent && !isExpression) return;
+      const name = nameOf(column.name);
+      out.push(
+        finding(sl003, stmt, {
+          title: `ADD COLUMN "${name}" has a non-constant default — SQLite refuses it`,
+          message:
+            `ALTER TABLE ADD COLUMN only accepts a constant default; ${isCurrent ? String(nameOf(expr.name)).toUpperCase() : "an expression in parentheses"} fails with "Cannot add a column with non-constant default" and "${table}" is unchanged. ` +
+            `Use a constant default (or none) and set the value from the application or a trigger.`,
+          object: { table, column: name },
+        }),
+      );
+    });
+    return out;
+  },
+};
+
+/** SL004: GENERATED ... STORED on an added column — the statement fails. */
+export const sl004: SlRule = {
+  meta: sl004Meta,
+  check(ctx) {
+    const out: Finding[] = [];
+    eachAddedColumn(ctx, (stmt, table, column) => {
+      const generated = constraintOf(column, "constraint_generated");
+      const storage = generated?.storageKw ?? generated?.constraint?.storageKw;
+      if (!generated || String(storage?.name ?? "").toUpperCase() !== "STORED") return;
+      const name = nameOf(column.name);
+      out.push(
+        finding(sl004, stmt, {
+          title: `ADD COLUMN "${name}" GENERATED ... STORED is rejected by SQLite`,
+          message:
+            `Only VIRTUAL generated columns can be added with ALTER TABLE; a STORED one fails ("cannot add a STORED column") and "${table}" is unchanged. ` +
+            `Declare it VIRTUAL, or make it part of a table rebuild.`,
+          object: { table, column: name },
+        }),
+      );
+    });
+    return out;
+  },
+};
+
+/** SL005: REFERENCES with a non-NULL default — fails whenever foreign keys are enforced. */
+export const sl005: SlRule = {
+  meta: sl005Meta,
+  check(ctx) {
+    const out: Finding[] = [];
+    eachAddedColumn(ctx, (stmt, table, column) => {
+      const references = constraintOf(column, "references_specification") ?? constraintOf(column, "constraint_foreign_key");
+      if (!references) return;
+      if (isNullDefault(column)) return;
+      const name = nameOf(column.name);
+      out.push(
+        finding(sl005, stmt, {
+          title: `ADD COLUMN "${name}" REFERENCES with a non-NULL default fails when foreign keys are on`,
+          message:
+            `With PRAGMA foreign_keys=ON — the setting most applications use — SQLite rejects this statement ("Cannot add a REFERENCES column with non-NULL default value"); with it off the statement passes, so the outcome depends on the runner's connection. ` +
+            `Add the column with a NULL default and backfill it.`,
+          object: { table, column: name },
+        }),
+      );
+    });
+    return out;
+  },
+};
+
+/** SL008: a CHECK constraint on an added column makes SQLite scan the whole table. */
+export const sl008: SlRule = {
+  meta: sl008Meta,
+  check(ctx) {
+    const out: Finding[] = [];
+    eachAddedColumn(ctx, (stmt, table, column) => {
+      const check = constraintOf(column, "constraint_check");
+      const generatedNotNull = constraintOf(column, "constraint_generated") && constraintOf(column, "constraint_not_null");
+      if (!check && !generatedNotNull) return;
+      const name = nameOf(column.name);
+      const what = check ? "a CHECK constraint" : "NOT NULL on a generated column";
+      out.push(
+        finding(sl008, stmt, {
+          title: `ADD COLUMN "${name}" with ${what} scans every row of "${table}"`,
+          message:
+            `Adding a column is schema-only in SQLite — except with ${what}, where the whole table is read under the write lock to verify existing rows before the change commits. ` +
+            `On a large table, schedule it; or add the column without the constraint and enforce it in a later rebuild.`,
+          object: { table, column: name },
+        }),
+      );
+    });
+    return out;
+  },
+};

package/src/rules/dml-and-maintenance.ts

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: Apache-2.0
+/** Statements that hold SQLite's single write lock for the size of the database rather than the size of the change. */
+import type { Finding } from "@bolvrk/engine";
+import { hasWhere, insideTransaction, tableCreatedInMigration, tableOf } from "../helpers";
+import { sl013Meta, sl014Meta, sl015Meta } from "../metas/index";
+import { finding, type SlRule } from "../rule";
+
+/** SL013: UPDATE / DELETE with no WHERE. */
+export const sl013: SlRule = {
+  meta: sl013Meta,
+  check(ctx) {
+    const out: Finding[] = [];
+    for (const stmt of ctx.migration.statements) {
+      if (stmt.node.type !== "update_stmt" && stmt.node.type !== "delete_stmt") continue;
+      if (hasWhere(stmt)) continue;
+      const table = tableOf(stmt) ?? "";
+      if (table && tableCreatedInMigration(ctx.migration, stmt.index, table)) continue;
+      const kind = stmt.node.type === "update_stmt" ? "UPDATE" : "DELETE";
+      out.push(
+        finding(sl013, stmt, {
+          title: `${kind} with no WHERE touches every row of "${table}"`,
+          message:
+            `Every row changes in one write transaction; SQLite's single writer holds the lock for the whole statement and every other writer waits or fails with SQLITE_BUSY, while the journal grows by the size of the change. ` +
+            `Add the predicate — and if this is a backfill, batch it by rowid range from a job.`,
+          object: { table },
+        }),
+      );
+    }
+    return out;
+  },
+};
+
+/** SL014: VACUUM — an error inside a transaction, a whole-file rewrite outside one. */
+export const sl014: SlRule = {
+  meta: sl014Meta,
+  check(ctx) {
+    const out: Finding[] = [];
+    const inTx = insideTransaction(ctx.migration);
+    for (const stmt of ctx.migration.statements) {
+      if (stmt.node.type !== "vacuum_stmt") continue;
+      // VACUUM INTO writes a copy elsewhere and leaves the live file alone — a backup, not a rewrite.
+      if ((stmt.node as Record<string, any>).intoKw) continue;
+      const inside = inTx[stmt.index] === true;
+      out.push(
+        finding(sl014, stmt, {
+          severity: inside ? "critical" : sl014Meta.defaultSeverity,
+          title: inside ? "VACUUM inside a transaction fails" : "VACUUM rewrites the whole database file",
+          message: inside
+            ? `SQLite refuses VACUUM while a transaction is open ("cannot VACUUM from within a transaction"), so the migration stops here. Vacuum from an operational job, outside any transaction.`
+            : `VACUUM copies the entire database into a temporary file and swaps it in: up to twice the database's size in free space, and the write lock held for the whole rewrite. It belongs in a maintenance job, not a migration — and if the runner wraps this file in a transaction it fails outright.`,
+        }),
+      );
+    }
+    return out;
+  },
+};
+
+/** SL015: REINDEX with no target. */
+export const sl015: SlRule = {
+  meta: sl015Meta,
+  check(ctx) {
+    const out: Finding[] = [];
+    for (const stmt of ctx.migration.statements) {
+      if (stmt.node.type !== "reindex_stmt") continue;
+      if ((stmt.node as Record<string, any>).name) continue;
+      out.push(
+        finding(sl015, stmt, {
+          title: "REINDEX with no argument rebuilds every index in the database",
+          message: `All indexes of every attached database are rebuilt in one write transaction — the lock is held for the total. Name the index or table that needs it (REINDEX is only needed after a collation change).`,
+        }),
+      );
+    }
+    return out;
+  },
+};

package/src/rules/index.ts

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+import type { SlRule } from "../rule";
+import { sl001, sl002, sl003, sl004, sl005, sl008 } from "./add-column";
+import { sl013, sl014, sl015 } from "./dml-and-maintenance";
+import { sl016, sl017, sl018 } from "./indexes-and-types";
+import { sl031, sl032, sl033, sl034, sl035 } from "./performance";
+import { sl009, sl010, sl011, sl012, sl019 } from "./rebuild-pragmas";
+import { sl020, sl021, sl022, sl023, sl024, sl025, sl026, sl027, sl028, sl029, sl030 } from "./schema-and-transactions";
+import { sl006, sl007 } from "./table-shape";
+
+export { SL_RULE_CORPUS_VERSION, SQLITE_RULE_IDS, sqliteMetas } from "../metas/index";
+export type { SlRule, SlRuleContext } from "../rule";
+
+/** The SL corpus, in id order. */
+export const allSqliteRules: readonly SlRule[] = [
+  sl001, sl002, sl003, sl004, sl005, sl006, sl007, sl008, sl009, sl010, sl011, sl012, sl013, sl014, sl015, sl016, sl017, sl018, sl019,
+  sl020, sl021, sl022, sl023, sl024, sl025, sl026, sl027, sl028, sl029, sl030, sl031, sl032, sl033, sl034, sl035,
+];