@starci/eslint-canon-be 1.8.0 → 2.0.0

package/query-safety.mjs

@@ -1,274 +1,240 @@
 /**
- * The rules that keep a database call safe to run in production.
+ * The rules that keep a database call safe to run in production (R36, R68, R69, R77).
  *
- * - `no-interpolated-sql` (R68 `BE_SQL_INTERPOLATED`) refuses SQL text built from a runtime value. A value
- *   reaches the statement as a numbered parameter (`$1`), never as spliced text.
- * - `query-needs-limit` (R69 `BE_QUERY_UNBOUNDED`) refuses a read that returns every matching row. A list read
- *   states its bound: `take`, `limit`, `LIMIT`, or a page cursor.
+ * SQL text is a `SqlText` constant built with the `sql` tag in a persistence `<name>.sql.ts`; a dynamic identifier is a
+ * `SqlIdent` from `ident()`; a value is a numbered parameter. Every receiver is identified by its TypeScript type
+ * (`EntityManager`, `QueryRunner`, `DataSource` from `typeorm`), never by its name, and every path question goes to the
+ * HFS slot view. No rule here parses SQL text: what a statement reads and writes is judged by the architecture
+ * machine (R86).
  *
- * Both read one file's syntax only. Where the syntax cannot prove a call safe or unsafe (a statement held in a
- * variable, an options object built elsewhere) the rule stays silent: a rule that guesses teaches authors to
- * ignore it.
+ * - `sql-text-only` (R36 `BE_SQL_OUTSIDE_PERSISTENCE`) - the first argument of `.query(` is a `SqlText`, and the `sql`
+ *   tag is called only in a persistence `<name>.sql.ts`.
+ * - `no-query-builder` (R36) - no `createQueryBuilder(` call.
+ * - `no-interpolated-sql` (R68 `BE_SQL_INTERPOLATED`) - a substitution inside the `sql` tag is a `SqlIdent`; a `.query(`
+ *   string built by template or concatenation is refused.
+ * - `query-needs-limit` (R69 `BE_QUERY_UNBOUNDED`) - `find`, `findBy` and `findAndCount` on an `EntityManager` carry `take`.
+ * - `no-query-in-loop` (R77 `BE_QUERY_IN_LOOP`) - an `EntityManager` read does not run once per element of a loop.
+ *
+ * A migration is hand-written DDL run once by `apps/migrate`; its `queryRunner.query(...)` takes plain text.
  */
-import { keyName, staticText, walk } from "./lib/ast.mjs"
-import { isDeclarationFile, isTestLane, normalizePath } from "./lib/path.mjs"
-
-const SQL_VERB = /\b(?:SELECT|INSERT|UPDATE|DELETE|WITH)\b/i
-
-/** A migration writes DDL once, by hand, with no caller input: interpolation there is a build step, not a hole. */
-const isMigrationPath = (filename) => /\/migrations\/[^/]+\.[cm]?ts$/.test(normalizePath(filename))
+import { keyName } from "./lib/ast.mjs"
+import { hfsOf } from "./lib/hfs.mjs"
+import { baseNameOf, infraTypeOf, isMigrationFile } from "./lib/persistence.mjs"
+import { isPackageType, typeOrigins } from "./lib/types.mjs"
 
 /** The property a call goes through: `manager.query(...)` gives `query`. */
 const calleeProperty = (node) =>
-  node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.property.type === "Identifier"
-    ? node.callee.property.name
-    : null
-
-/** The last name of the receiver: `this.manager` gives `manager`, `em` gives `em`. */
-const receiverName = (callee) => {
-  const object = callee.object
-  if (object.type === "Identifier") return object.name
-  if (object.type === "MemberExpression" && !object.computed && object.property.type === "Identifier") return object.property.name
-  return null
+    node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.property.type === "Identifier"
+        ? node.callee.property.name
+        : null
+
+/** Whether a type origin is declared by the platform database capability (where `SqlText`, `SqlIdent` and `sql` live). */
+const fromDatabaseCapability = (hfs, origin) => {
+    const found = hfs.classify(origin.file)
+    return found.slot === "be.platform" && found.bindings?.capability === "database"
 }
 
-/** UPPER_SNAKE names a module constant: a fixed column list is code, not input. */
-const isConstantName = (name) => /^[A-Z][A-Z0-9_]*$/.test(name)
-
-/** Identifier helpers that quote an identifier are the sanctioned way to put a name into a statement. */
-const IDENT_HELPERS = new Set(["quoteIdent", "quoteIdentifier", "quoteIdentifiers", "sqlIdent", "sqlIdentifiers", "sqlSetClause", "escapeIdentifier"])
+/** Whether the value at `node` has the branded type `name` exported by the platform database capability. */
+const hasBrand = (context, hfs, node, name) => typeOrigins(context, node).some((origin) => origin.name === name && fromDatabaseCapability(hfs, origin))
+
+/** Whether a call goes through `.query` on a manager, runner or data source. */
+const isQueryCall = (context, node) => calleeProperty(node) === "query" && infraTypeOf(context, node.callee.object) !== null
+
+// -- R36 -----------------------------------------------------------------------------------------------
+
+/** SQL text is `SqlText`, and only a persistence `.sql.ts` builds it. */
+export const sqlTextOnly = {
+    meta: {
+        type: "problem",
+        docs: { description: "`.query(...)` takes a `SqlText`, and the `sql` tag is called only in a persistence `<name>.sql.ts`." },
+        schema: [],
+        messages: {
+            notSqlText:
+                "The first argument of `.query(...)` is not a `SqlText`. SQL text is a constant built with the `sql` tag in the `persistence/<name>.sql.ts` of the owning capability and imported here; the row shape and its mapper live in `<name>.rows.ts`.",
+            tagOutsideSqlFile:
+                "The `sql` tag is called outside a persistence `<name>.sql.ts`. Write the statement as an exported constant in the `persistence/<name>.sql.ts` of the capability that owns the tables, and import it.",
+        },
+    },
+    create(context) {
+        const hfs = hfsOf(context)
+        const filename = context.filename || context.getFilename()
+        const migration = isMigrationFile(hfs, filename)
+        const sqlFile = hfs.slotOf(filename) === "be.persistence" && baseNameOf(filename).endsWith(".sql.ts")
+        const isSqlTag = (node) => typeOrigins(context, node).some((origin) => origin.name === "sql" && fromDatabaseCapability(hfs, origin))
+        return {
+            CallExpression(node) {
+                if (isSqlTag(node.callee) && !sqlFile) context.report({ node, messageId: "tagOutsideSqlFile" })
+                if (migration || !isQueryCall(context, node)) return
+                const first = node.arguments[0]
+                if (!first || !hasBrand(context, hfs, first, "SqlText")) context.report({ node: first ?? node, messageId: "notSqlText" })
+            },
+            TaggedTemplateExpression(node) {
+                if (isSqlTag(node.tag) && !sqlFile) context.report({ node, messageId: "tagOutsideSqlFile" })
+            },
+        }
+    },
+}
 
-/** Whether a substitution inside a SQL template is one of the shapes that cannot carry input. */
-const isSafeSubstitution = (expression, precedingText) => {
-  if (precedingText.endsWith("$")) return true
-  if (expression.type === "Identifier") return isConstantName(expression.name)
-  if (expression.type === "MemberExpression" && !expression.computed && expression.property.type === "Identifier") {
-    return isConstantName(expression.property.name)
-  }
-  if (expression.type === "CallExpression" && expression.callee.type === "Identifier") return IDENT_HELPERS.has(expression.callee.name)
-  // `${locked ? "FOR UPDATE" : ""}` chooses between fixed strings
-  if (expression.type === "ConditionalExpression") {
-    const fixed = (branch) => branch.type === "Literal" && typeof branch.value === "string"
-    return fixed(expression.consequent) && fixed(expression.alternate)
-  }
-  return false
+/** There is one way to write a complex read, and it is SQL. */
+export const noQueryBuilder = {
+    meta: {
+        type: "problem",
+        docs: { description: "No `createQueryBuilder(...)` call." },
+        schema: [],
+        messages: {
+            builder:
+                "`createQueryBuilder(...)` is banned. A read is `manager.find(Entity, { where, take })`, or a `SqlText` constant in the capability's `persistence/<name>.sql.ts` run with `manager.query(...)`.",
+        },
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                const callee = node.callee
+                const name = callee.type === "Identifier" ? callee.name : calleeProperty(node)
+                if (name === "createQueryBuilder") context.report({ node, messageId: "builder" })
+            },
+        }
+    },
 }
 
 // -- R68 -----------------------------------------------------------------------------------------------
 
 /** A statement is text plus parameters; a value never becomes part of the text. */
 export const noInterpolatedSql = {
-  meta: {
-    type: "problem",
-    docs: { description: "SQL text passed to `.query(...)` contains no runtime substitution; values are numbered parameters." },
-    schema: [],
-    messages: {
-      interpolated:
-        "This SQL text is built from `{{expression}}`. A value spliced into a statement is an injection hole and defeats the plan cache. Pass the value as a numbered parameter (`$1`) in the array argument. A column list is a module constant in UPPER_SNAKE case; a dynamic identifier goes through `quoteIdent(...)` or `sqlIdent(...)`; a variable SET list goes through `sqlSetClause(...)`, which checks every column against a fixed allowlist and numbers the placeholders. A choice between fixed strings is a ternary of literals.",
-      concatenated:
-        "This SQL text is joined with `+`. A value spliced into a statement is an injection hole. Pass the value as a numbered parameter (`$1`) in the array argument.",
+    meta: {
+        type: "problem",
+        docs: { description: "Inside the `sql` tag every substitution is a `SqlIdent`; a `.query(...)` string is never built by template or concatenation." },
+        schema: [],
+        messages: {
+            substitution:
+                "This substitution (`{{expression}}`) is not a `SqlIdent`. A value spliced into a statement is an injection hole and defeats the plan cache. Pass a value as a numbered parameter (`$1`) in the array argument; a dynamic identifier goes through `ident(name, allowed)`, which checks it against a fixed list and is the only substitution the `sql` tag accepts.",
+            built:
+                "This SQL text is built with a template or a `+`. A value spliced into a statement is an injection hole. Write the statement as a `SqlText` constant with the `sql` tag in `persistence/<name>.sql.ts` and pass values as numbered parameters (`$1`) in the array argument.",
+        },
     },
-  },
-  create(context) {
-    const filename = context.filename || context.getFilename()
-    if (isTestLane(filename) || isDeclarationFile(filename) || isMigrationPath(filename)) return {}
-    const sourceCode = context.sourceCode || context.getSourceCode()
-    return {
-      CallExpression(node) {
-        if (calleeProperty(node) !== "query") return
-        const first = node.arguments[0]
-        if (!first) return
-        if (first.type === "TemplateLiteral" && first.expressions.length > 0) {
-          const text = first.quasis.map((quasi) => quasi.value.cooked ?? "").join(" ")
-          if (!SQL_VERB.test(text)) return
-          first.expressions.forEach((expression, index) => {
-            const preceding = first.quasis[index]?.value.cooked ?? ""
-            if (isSafeSubstitution(expression, preceding)) return
-            context.report({ node: expression, messageId: "interpolated", data: { expression: sourceCode.getText(expression).slice(0, 60) } })
-          })
-        } else if (first.type === "BinaryExpression" && first.operator === "+") {
-          let sql = false
-          walk(first, (child) => {
-            if (child.type === "Literal" && typeof child.value === "string" && SQL_VERB.test(child.value)) sql = true
-          })
-          if (sql) context.report({ node: first, messageId: "concatenated" })
+    create(context) {
+        const hfs = hfsOf(context)
+        const sourceCode = context.sourceCode || context.getSourceCode()
+        const filename = context.filename || context.getFilename()
+        const migration = isMigrationFile(hfs, filename)
+        return {
+            TaggedTemplateExpression(node) {
+                if (!typeOrigins(context, node.tag).some((origin) => origin.name === "sql" && fromDatabaseCapability(hfs, origin))) return
+                for (const expression of node.quasi.expressions) {
+                    if (!hasBrand(context, hfs, expression, "SqlIdent")) {
+                        context.report({ node: expression, messageId: "substitution", data: { expression: sourceCode.getText(expression).slice(0, 60) } })
+                    }
+                }
+            },
+            CallExpression(node) {
+                if (migration || !isQueryCall(context, node)) return
+                const first = node.arguments[0]
+                if (first?.type === "TemplateLiteral" && first.expressions.length > 0) context.report({ node: first, messageId: "built" })
+                else if (first?.type === "BinaryExpression" && first.operator === "+") context.report({ node: first, messageId: "built" })
+            },
         }
-      },
-    }
-  },
+    },
 }
 
 // -- R69 -----------------------------------------------------------------------------------------------
 
-const AGGREGATE_ONLY = /^\s*(?:WITH\b[\s\S]*?\)\s*)?SELECT\s+(?:COUNT|SUM|MAX|MIN|AVG|EXISTS|NEXTVAL|NOW|CURRENT_|PG_|SET_CONFIG|1\b|TRUE|FALSE|\(?\s*SELECT\s+1)/i
-const HAS_BOUND = /\bLIMIT\b|\bFETCH\s+FIRST\b/i
-/** A lookup by the primary key returns one row, so it needs no bound. */
-const BY_PRIMARY_KEY = /\bWHERE\s+"?(?:[a-z_]+\.)?id"?\s*=\s*\$\d+\s*(?:FOR\s+UPDATE\s*)?(?:RETURNING[^;]*)?$/i
-
-const QUERY_BUILDER_READS = new Set(["getMany", "getRawMany", "getManyAndCount", "getRawAndEntities"])
-const REPOSITORY_READS = new Set(["find", "findBy", "findAndCount", "findAndCountBy"])
-const REPOSITORY_RECEIVER = /^(?:manager|entityManager|em|repo|repository|[a-z]\w*Repository|[a-z]\w*Repo)$/
-
-/** The chain of calls a query builder read hangs off, as method names, innermost first. */
-const chainNames = (callee) => {
-  const names = []
-  let current = callee
-  while (current) {
-    if (current.type === "MemberExpression" && !current.computed && current.property.type === "Identifier") {
-      names.push(current.property.name)
-      current = current.object
-    } else if (current.type === "CallExpression") {
-      current = current.callee
-    } else if (current.type === "AwaitExpression") {
-      current = current.argument
-    } else break
-  }
-  return names
-}
-
-/** Whether an object literal names a property, by key. */
-const objectHasKey = (node, names) =>
-  node?.type === "ObjectExpression" && node.properties.some((property) => property.type === "Property" && names.includes(keyName(property.key)))
-
-/** Whether a `where` object states the primary key, which bounds the read to one row. */
-const whereHasPrimaryKey = (node) => {
-  if (node?.type !== "ObjectExpression") return false
-  if (objectHasKey(node, ["id"])) return true
-  const where = node.properties.find((property) => property.type === "Property" && keyName(property.key) === "where")
-  return where ? whereHasPrimaryKey(where.value) : false
-}
+const BOUNDED_READS = new Set(["find", "findBy", "findAndCount", "findAndCountBy"])
 
 /** A list read states its bound. */
 export const queryNeedsLimit = {
-  meta: {
-    type: "problem",
-    docs: { description: "A read that can return many rows states `take`, `limit` or `LIMIT`." },
-    schema: [],
-    messages: {
-      builder:
-        "`.{{method}}()` reads every matching row: one busy tenant turns it into a full scan held in memory. Add `.take(n)` (or `.limit(n)`) with a named bound, or page with a cursor.",
-      find:
-        "`.{{method}}(...)` on a repository reads every matching row and states no `take`. Pass `take` with a named bound (the entity manager form is `manager.find(Entity, { where, take })`), or page with a cursor. A lookup by `id` is exempt.",
-      findBy:
-        "`.findBy(...)` cannot take a bound, so it reads every matching row. Use `.find({ where, take })` with a named bound, or page with a cursor. A lookup by `id` is exempt.",
-      raw:
-        "This `SELECT` has no `LIMIT`. Add `LIMIT $n` with a named bound, or page by keyset. An aggregate (`COUNT`, `EXISTS`, `SUM`) and a lookup by `id` are exempt.",
+    meta: {
+        type: "problem",
+        docs: { description: "`find`, `findBy` and `findAndCount` on an `EntityManager` state `take`." },
+        schema: [],
+        messages: {
+            find:
+                "`.{{method}}(...)` reads every matching row and states no `take` in its options object. Pass `take` with a named bound (`manager.find(Entity, { where, take: LIST_ROWS_MAX })`), or page by keyset.",
+            findBy:
+                "`.{{method}}(...)` cannot take a bound, so it reads every matching row. Use `manager.find(Entity, { where, take })` with a named bound, or page by keyset.",
+        },
     },
-  },
-  create(context) {
-    const filename = context.filename || context.getFilename()
-    if (isTestLane(filename) || isDeclarationFile(filename) || isMigrationPath(filename)) return {}
-    return {
-      CallExpression(node) {
-        const method = calleeProperty(node)
-        if (!method) return
-        if (QUERY_BUILDER_READS.has(method)) {
-          const names = chainNames(node.callee.object.type === "CallExpression" ? node.callee.object.callee : node.callee.object)
-          if (names.includes("take") || names.includes("limit") || names.includes("getOne") || names.includes("getOneOrFail")) return
-          if (!names.includes("createQueryBuilder") && !names.includes("select") && !names.includes("where") && !names.includes("andWhere") && !names.includes("leftJoinAndSelect") && !names.includes("innerJoinAndSelect") && !names.includes("orderBy") && !names.includes("from")) return
-          context.report({ node: node.callee.property, messageId: "builder", data: { method } })
-          return
-        }
-        if (REPOSITORY_READS.has(method) && REPOSITORY_RECEIVER.test(receiverName(node.callee) ?? "")) {
-          const args = node.arguments
-          // manager.find(Entity, options) has the entity first; repository.find(options) has the options first
-          const options = method === "find" || method === "findAndCount" ? args.find((arg) => arg.type === "ObjectExpression") : undefined
-          const where = method === "findBy" || method === "findAndCountBy" ? args.find((arg) => arg.type === "ObjectExpression") : undefined
-          if (method === "find" || method === "findAndCount") {
-            const argument = args[args.length - 1]
-            if (!argument || argument.type !== "ObjectExpression") return // no static options to judge
-            if (objectHasKey(options, ["take", "limit"]) || whereHasPrimaryKey(options)) return
-            context.report({ node: node.callee.property, messageId: "find", data: { method } })
-          } else if (where) {
-            if (whereHasPrimaryKey(where)) return
-            context.report({ node: node.callee.property, messageId: "findBy", data: { method } })
-          }
-          return
+    create(context) {
+        return {
+            CallExpression(node) {
+                const method = calleeProperty(node)
+                if (!method || !BOUNDED_READS.has(method) || !isPackageType(context, node.callee.object, "EntityManager", "typeorm")) return
+                if (method === "findBy" || method === "findAndCountBy") {
+                    context.report({ node: node.callee.property, messageId: "findBy", data: { method } })
+                    return
+                }
+                const options = node.arguments[node.arguments.length - 1]
+                const hasTake =
+                    options?.type === "ObjectExpression"
+                    && options.properties.some((property) => property.type === "Property" && keyName(property.key) === "take")
+                if (!hasTake) context.report({ node: node.callee.property, messageId: "find", data: { method } })
+            },
         }
-        if (method === "query") {
-          const text = staticText(node.arguments[0])
-          const sql = text ?? (node.arguments[0]?.type === "TemplateLiteral" ? node.arguments[0].quasis.map((quasi) => quasi.value.cooked ?? "").join(" ") : null)
-          if (sql === null) return
-          if (!/^\s*(?:SELECT|WITH)\b/i.test(sql)) return
-          if (HAS_BOUND.test(sql) || AGGREGATE_ONLY.test(sql) || BY_PRIMARY_KEY.test(sql.trim().replace(/;$/, ""))) return
-          context.report({ node: node.arguments[0], messageId: "raw" })
-        }
-      },
-    }
-  },
+    },
 }
 
 // -- R77 -----------------------------------------------------------------------------------------------
 
-const LOOP_READS = new Set(["find", "findBy", "findOne", "findOneBy", "findOneOrFail", "findOneByOrFail", "findAndCount", "count", "countBy", "exists", "existsBy", "getOne", "getMany", "getRawMany", "getRawOne", "getCount", "query"])
-const LOOP_RECEIVER = /^(?:manager|entityManager|em|repo|repository|dataSource|queryRunner|[a-z]\w*Repository|[a-z]\w*Repo|[a-z]\w*Store)$/
+const LOOP_READS = new Set(["find", "findBy", "findOne", "findOneBy", "findOneOrFail", "findOneByOrFail", "findAndCount", "findAndCountBy", "count", "countBy", "exists", "existsBy"])
 const ITERATION_METHODS = new Set(["map", "forEach", "flatMap", "filter", "reduce", "some", "every"])
 const LOOP_STATEMENTS = new Set(["ForStatement", "ForOfStatement", "ForInStatement"])
 
 /** Whether `node` runs once per element: inside a `for` loop, or inside a callback of an array iteration method. */
 const insideIteration = (node) => {
-  let current = node.parent
-  while (current) {
-    if (LOOP_STATEMENTS.has(current.type)) return true
-    if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") {
-      const call = current.parent
-      return (
-        call?.type === "CallExpression"
-        && call.callee.type === "MemberExpression"
-        && !call.callee.computed
-        && call.callee.property.type === "Identifier"
-        && ITERATION_METHODS.has(call.callee.property.name)
-        && call.arguments.includes(current)
-      )
+    let current = node.parent
+    while (current) {
+        if (LOOP_STATEMENTS.has(current.type)) return true
+        if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") {
+            const call = current.parent
+            return (
+                call?.type === "CallExpression"
+                && call.callee.type === "MemberExpression"
+                && !call.callee.computed
+                && call.callee.property.type === "Identifier"
+                && ITERATION_METHODS.has(call.callee.property.name)
+                && call.arguments.includes(current)
+            )
+        }
+        current = current.parent
     }
-    current = current.parent
-  }
-  return false
+    return false
 }
 
 /** A read inside an iteration is N+1: one round trip per element. */
 export const noQueryInLoop = {
-  meta: {
-    type: "problem",
-    docs: { description: "A repository, entity-manager or query-builder read does not run once per element of a loop." },
-    schema: [],
-    messages: {
-      inLoop:
-        "`.{{method}}(...)` runs once per element, so the number of round trips grows with the input (N+1) and one large request holds a connection for as long as it takes. Read the rows once before the loop with `find({ where: { <key>: In(keys) }, take })` or `WHERE <key> = ANY($1)`, index them in a `Map`, and look up inside the loop. A polling `while` loop is not this rule's business.",
+    meta: {
+        type: "problem",
+        docs: { description: "An `EntityManager` read does not run once per element of a loop." },
+        schema: [],
+        messages: {
+            inLoop:
+                "`.{{method}}(...)` runs once per element, so the number of round trips grows with the input (N+1) and one large request holds a connection for as long as it takes. Read the rows once before the loop with `find(Entity, { where: { <key>: In(keys) }, take })` or a `SqlText` with `WHERE <key> = ANY($1)`, index them in a `Map`, and look up inside the loop. A polling `while` loop is not this rule's business.",
+        },
     },
-  },
-  create(context) {
-    const filename = context.filename || context.getFilename()
-    if (isTestLane(filename) || isDeclarationFile(filename) || isMigrationPath(filename)) return {}
-    return {
-      CallExpression(node) {
-        const method = calleeProperty(node)
-        if (!method || !LOOP_READS.has(method)) return
-        const chain = chainNames(node.callee)
-        const builder = chain.includes("createQueryBuilder")
-        if (!builder && !LOOP_RECEIVER.test(receiverName(node.callee) ?? "")) return
-        if (method === "query") {
-          const first = node.arguments[0]
-          const sql = staticText(first) ?? (first?.type === "TemplateLiteral" ? first.quasis.map((quasi) => quasi.value.cooked ?? "").join(" ") : null)
-          if (sql === null || !/^\s*(?:SELECT|WITH)\b/i.test(sql)) return
+    create(context) {
+        return {
+            CallExpression(node) {
+                const method = calleeProperty(node)
+                if (!method || !LOOP_READS.has(method) || !insideIteration(node)) return
+                if (infraTypeOf(context, node.callee.object) === "EntityManager") context.report({ node: node.callee.property, messageId: "inLoop", data: { method } })
+            },
         }
-        if (!insideIteration(node)) return
-        context.report({ node: node.callee.property, messageId: "inLoop", data: { method } })
-      },
-    }
-  },
+    },
 }
 
 /** The rules this law contributes to the plugin. */
 export const rules = {
-  "no-interpolated-sql": noInterpolatedSql,
-  "query-needs-limit": queryNeedsLimit,
-  "no-query-in-loop": noQueryInLoop,
+    "sql-text-only": sqlTextOnly,
+    "no-query-builder": noQueryBuilder,
+    "no-interpolated-sql": noInterpolatedSql,
+    "query-needs-limit": queryNeedsLimit,
+    "no-query-in-loop": noQueryInLoop,
 }
 
-/** Both start at error: no baseline exists, and the repositories' fix lanes clear the debt. */
+/** Every rule of this law ships at `error`; no baseline exists. */
 export const recommended = {
-  "starci-be/no-interpolated-sql": "error",
-  "starci-be/query-needs-limit": "error",
-  "starci-be/no-query-in-loop": "error",
+    "starci-be/sql-text-only": "error",
+    "starci-be/no-query-builder": "error",
+    "starci-be/no-interpolated-sql": "error",
+    "starci-be/query-needs-limit": "error",
+    "starci-be/no-query-in-loop": "error",
 }