fix(mssql): reject a parenthesised or negated constant tautology in a WHERE clause

The shared guard recognises `OR 1` but not `OR (1)`, `OR ((1))`, `OR NOT 0`, or
`OR NOT (FALSE)` — a parenthesis or a NOT between the operator and the constant
hides it. Both patterns require the constant to be the whole parenthesised term,
so a real disjunct such as `OR (1 = priority)` is untouched.

This narrows the gap rather than closing it, and is not meant to close it: an
always-true expression is not lexically decidable in general, which is why the
WHERE screen stays documented as defense-in-depth rather than a boundary.

Author: waleedlatif1

apps/sim/app/api/tools/mssql/utils.test.ts

@@ -145,6 +145,29 @@ describe('buildUpdateQuery / buildDeleteQuery WHERE screening', () => {
     expect(() => buildDeleteQuery('dbo.users', `[a"] = 1 OR 1=1`)).toThrow(/bracketed identifier/)
   })
 
+  /**
+   * The shared guard sees `OR 1` but not a parenthesised or negated constant.
+   * These are the specific forms it documents as undetected; the class as a
+   * whole is not lexically decidable, so this narrows rather than closes it.
+   */
+  it.each([
+    'id = 1 OR (1)',
+    'id = 1 OR ((1))',
+    'id = 1 OR NOT 0',
+    'id = 1 OR NOT (0)',
+    'id = 1 OR (TRUE)',
+  ])('rejects the constant tautology %s', (where) => {
+    expect(() => buildDeleteQuery('dbo.users', where)).toThrow()
+  })
+
+  it.each([
+    'id = 1 OR (priority = 2)',
+    'id = 1 OR (1 = priority)',
+    "status = 'open' OR (retries < 3)",
+  ])('still accepts the real disjunct %s', (where) => {
+    expect(() => buildDeleteQuery('dbo.users', where)).not.toThrow()
+  })
+
   it.each([
     ['a semicolon-less batch', "id = 1 DBCC SHRINKDATABASE('app')"],
     ['an appended SELECT', 'id = 1 SELECT secret FROM dbo.credentials'],

apps/sim/app/api/tools/mssql/utils.ts

@@ -420,6 +420,26 @@ const MSSQL_WHERE_SELECT = /\bselect\b/i
  * views still reachable as `master..sysobjects`.
  * @see https://learn.microsoft.com/en-us/sql/relational-databases/system-catalog-views/catalog-views-transact-sql
  */
+/**
+ * Constant tautologies the shared guard's `OR <literal>` rule cannot see because
+ * a parenthesis or a `NOT` sits between the operator and the constant —
+ * `OR (1)`, `OR ((1))`, `OR NOT 0`, `OR NOT (FALSE)`.
+ *
+ * Both patterns require the constant to be the *whole* parenthesised term, so a
+ * real disjunct is untouched: `OR (1 = priority)` does not match, because a
+ * closing paren does not follow the digit.
+ *
+ * This narrows the gap; it does not close it, and it is not meant to. An
+ * always-true expression cannot be recognised lexically in general —
+ * `OR 2 > 1`, `OR LEN(x) >= 0`, and `OR id IS NOT NULL` all survive any pattern
+ * list — which is why {@link validateWhereClause} is documented as
+ * defense-in-depth rather than a boundary.
+ */
+const MSSQL_WHERE_CONSTANT_TAUTOLOGY: readonly RegExp[] = [
+  /\bor\s+(?:not\s+)*\(+\s*(?:\d+(?:\.\d+)?|true|false)\s*\)+/i,
+  /\bor\s+not\s+(?:\d+(?:\.\d+)?|true|false)\b/i,
+]
+
 const MSSQL_CATALOG_PATTERNS: readonly RegExp[] = [
   /information_schema/i,
   /\bsys\./i,
@@ -469,6 +489,7 @@ function validateWhereClause(where: string): void {
     MSSQL_STATEMENT_KEYWORDS.test(masked) ||
     MSSQL_PROCEDURE_PATTERN.test(masked) ||
     MSSQL_WHERE_SELECT.test(masked) ||
+    MSSQL_WHERE_CONSTANT_TAUTOLOGY.some((pattern) => pattern.test(masked)) ||
     MSSQL_CATALOG_PATTERNS.some((pattern) => pattern.test(masked))
   ) {
     throw new Error('WHERE clause contains potentially dangerous operation')