@bolvrk/engine-sqlite 0.1.4

package/LICENSE.md

@@ -0,0 +1,105 @@
+# Functional Source License, Version 1.1, ALv2 Future License
+
+## Abbreviation
+
+FSL-1.1-ALv2
+
+## Notice
+
+Copyright 2026 Bolvrk
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the Apache License, Version 2.0 that is effective on the second anniversary of
+the date we make the Software available. On or after that date, you may use the
+Software under the Apache License, Version 2.0, in which case the following
+will apply:
+
+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/README.md

@@ -0,0 +1,26 @@
+# @bolvrk/engine-sqlite
+
+SQLite migration danger rules for [Bolvrk](https://bolvrk.com) — the `SL###` corpus,
+over a real SQLite grammar ([sql-parser-cst](https://github.com/nene/sql-parser-cst)),
+never regex.
+
+**Alpha.** Static (tier 1) rules only, behind `--engine=sqlite` in the CLI:
+
+```bash
+npx bolvrk check migrations/*.sql --engine=sqlite
+```
+
+The rules cover the forms of `ALTER TABLE ADD COLUMN` SQLite refuses, the whole-table
+rewrite `DROP COLUMN` performs, the twelve-step table rebuild and the pragmas around
+it, unbounded writes, `VACUUM` and `REINDEX`, index builds under the single write lock,
+the rowid traps (`INT PRIMARY KEY`, `AUTOINCREMENT`, nullable keys), STRICT and child-key indexes, dependent views and triggers, deferred and nested transactions, non-deterministic index expressions and `ATTACH`. The credential rules `check` runs on Postgres (BC003, BC004) run here too. Every rule ships fixture
+migrations in both directions, and every "SQLite refuses this" claim is re-proven against
+a real SQLite in the test suite.
+
+Same findings contract as the Postgres engine (`engine: "sqlite"` on the report).
+Inline suppressions (`-- bolvrk-ignore SL001: reason`) work the same way.
+
+Rule reference: [docs/](docs/README.md).
+
+Licensing follows `@bolvrk/engine`: the rules and their metadata (`src/rules/`,
+`src/metas/`) are Apache-2.0; the parser wrapper and check pipeline are FSL-1.1-ALv2.

package/dist/engine.d.ts

@@ -0,0 +1,24 @@
+import { type CheckReport } from "@bolvrk/engine";
+import type { SlRule } from "./rule";
+export interface SqliteCheckOptions {
+    /** Override the rule set (used by tests); defaults to the full SL corpus. */
+    rules?: readonly SlRule[];
+    /** Skip the credential rules (BC003, BC004) that `check` runs on every engine. Default: run them. */
+    skipCredentials?: boolean;
+}
+/** The credential rules `bolvrk check` runs on Postgres and, through here, on SQLite too — text-level, engine-neutral. */
+export declare const CREDENTIAL_RULE_IDS: ReadonlySet<string>;
+/**
+ * Run a SQLite migration through the SL corpus. Same findings contract as
+ * the Postgres engine, same determinism guarantee: identical input produces
+ * byte-identical report JSON. Static (tier 1) only — SQLite has no server
+ * to introspect, and the rules that would want a live file (table sizes)
+ * say so in their message instead.
+ *
+ * Inline suppressions (`-- bolvrk-ignore SL001: reason`) work exactly as on
+ * Postgres: the engine's own collector reads the comment lines between
+ * statements as the parser located them.
+ */
+export declare function checkSqliteMigration(sql: string, options?: SqliteCheckOptions): CheckReport;
+/** 1-based start line of each statement — for SARIF locations. */
+export declare function sqliteStatementStartLines(sql: string): number[];

package/dist/helpers.d.ts

@@ -0,0 +1,77 @@
+/**
+ * CST helpers the SL rules are written against: one implementation of
+ * "which table does this statement touch", "is this statement inside an
+ * explicit transaction", and the shape of a column definition.
+ */
+import type { Node } from "sql-parser-cst";
+import type { ParsedSqliteMigration, ParsedSqliteStatement } from "./parser";
+type AnyNode = Record<string, any>;
+/** Unquoted name of an identifier or a `schema.name` member expression. */
+export declare function nameOf(node: AnyNode | undefined | null): string | undefined;
+/** Items of a `list_expr`, or the single node when the parser did not wrap one. */
+export declare function items(node: AnyNode | undefined | null): AnyNode[];
+/** The ALTER TABLE actions of a statement (empty for anything else). */
+export declare function alterActions(stmt: ParsedSqliteStatement): AnyNode[];
+/** Column definitions added by `ALTER TABLE ... ADD [COLUMN]` in this statement. */
+export declare function addedColumns(stmt: ParsedSqliteStatement): AnyNode[];
+/** Column definitions of a CREATE TABLE statement (constraints declared at table level excluded). */
+export declare function createdColumns(stmt: ParsedSqliteStatement): AnyNode[];
+/** Table-level constraints of a CREATE TABLE statement. */
+export declare function tableConstraints(stmt: ParsedSqliteStatement): AnyNode[];
+/** A column definition's constraint of the given CST type, if any. */
+export declare function constraintOf(column: AnyNode, type: string): AnyNode | undefined;
+/** Keyword name(s) of a data type node, uppercased and joined — `INT`, `INTEGER`, `VARCHAR`. */
+export declare function dataTypeName(column: AnyNode): string;
+/** Table options of CREATE TABLE (`WITHOUT ROWID`, `STRICT`), uppercased. */
+export declare function tableOptions(stmt: ParsedSqliteStatement): string[];
+/** The primary table a statement targets, if any. */
+export declare function tableOf(stmt: ParsedSqliteStatement): string | undefined;
+/** Tables dropped by a DROP TABLE statement. */
+export declare function droppedTables(stmt: ParsedSqliteStatement): string[];
+/** True when `table` is created by an earlier statement of this migration. */
+export declare function tableCreatedInMigration(migration: ParsedSqliteMigration, beforeIndex: number, table: string): boolean;
+/** One "drop, then rename another table onto the name" pair in a migration. */
+export interface TableRebuild {
+    /** The DROP TABLE statement. */
+    drop: ParsedSqliteStatement;
+    /** The ALTER TABLE ... RENAME TO statement that restores the dropped name. */
+    rename: ParsedSqliteStatement;
+    /** The name being rebuilt. */
+    table: string;
+    /** The table renamed onto it. */
+    replacement: string;
+    /** True when the replacement was created earlier in this file — the documented recipe rather than a swap of two live tables. */
+    replacementCreatedHere: boolean;
+    /** An INSERT into the replacement that reads from the old table, issued before the DROP. */
+    copy?: ParsedSqliteStatement;
+}
+/**
+ * Every rebuild in the migration: DROP TABLE x followed, later in the file,
+ * by ALTER TABLE y RENAME TO x. The interim table's name plays no part —
+ * the match is structural, on the dropped name coming back as a rename
+ * target. Cross-file rebuilds are invisible; the engine sees one file.
+ */
+export declare function tableRebuilds(migration: ParsedSqliteMigration): TableRebuild[];
+/** The WHERE clause of an UPDATE / DELETE, if present. */
+export declare function hasWhere(stmt: ParsedSqliteStatement): boolean;
+export interface PragmaRead {
+    name: string;
+    /** Assigned value, lowercased (`off`, `on`, `0`, `wal`); undefined for a bare query like `PRAGMA foreign_key_check`. */
+    value?: string;
+}
+/** Name and value of a PRAGMA statement; undefined for anything else. */
+export declare function pragmaOf(stmt: ParsedSqliteStatement): PragmaRead | undefined;
+/** SQLite's boolean spellings for a pragma value. */
+export declare function pragmaIsOff(value: string | undefined): boolean;
+export declare function pragmaIsOn(value: string | undefined): boolean;
+/**
+ * For each statement, whether it runs inside an explicit transaction opened
+ * earlier in the file (BEGIN ... COMMIT/END/ROLLBACK). Statements before any
+ * BEGIN, or after the matching COMMIT, are "autocommit" from the file's point
+ * of view — a migration runner may still wrap the whole file, which is why
+ * rules that depend on this say so in their message.
+ */
+export declare function insideTransaction(migration: ParsedSqliteMigration): boolean[];
+/** Depth-first descendants of a CST node matching a predicate. */
+export declare function descendants(node: Node | AnyNode | undefined, predicate: (node: AnyNode) => boolean): AnyNode[];
+export {};