@nitra/cursor 1.8.145 → 1.8.150

package/scripts/utils/mssql-pool-scan.mjs

@@ -22,95 +22,20 @@
  */
 import { parseSync } from 'oxc-parser'
 
+import {
+  isFunctionNode,
+  isJoinCall,
+  isSqlListContextTemplate,
+  langFromPath,
+  normalizeSnippet,
+  offsetToLine,
+  walkAstWithAncestors
+} from './ast-scan-utils.mjs'
+
 const SOURCE_FILE_RE = /\.([cm]?[jt]sx?)$/
-const SQL_LIST_CONTEXT_RE = /\b(in|values)\b\s*\(/iu
 const IN_PLACEHOLDER_END_RE = /\bin\s*\(\s*$/iu
 const NUMERIC_PARSE_FN_NAMES = new Set(['parseInt', 'parseFloat', 'Number', 'BigInt'])
 
-/**
- * Мова для Oxc за шляхом файлу (розширення).
- * @param {string} filePath віртуальний або реальний шлях до файлу
- * @returns {'js' | 'jsx' | 'ts' | 'tsx'} значення опції `lang` для `parseSync`
- */
-function langFromPath(filePath) {
-  const lower = filePath.toLowerCase()
-  if (lower.endsWith('.tsx')) return 'tsx'
-  if (lower.endsWith('.ts') || lower.endsWith('.mts') || lower.endsWith('.cts')) return 'ts'
-  if (lower.endsWith('.jsx')) return 'jsx'
-  return 'js'
-}
-
-/**
- * Номер рядка (1-based) за зміщенням у буфері.
- * @param {string} content повний текст файлу
- * @param {number} offset байтове зміщення початку фрагмента
- * @returns {number} номер рядка від 1
- */
-function offsetToLine(content, offset) {
-  let line = 1
-  const n = Math.min(offset, content.length)
-  for (let i = 0; i < n; i++) {
-    if (content.codePointAt(i) === 10) line++
-  }
-  return line
-}
-
-/**
- * Стискає пробіли для повідомлення про порушення.
- * @param {string} s фрагмент коду
- * @returns {string} скорочений однорядковий рядок
- */
-function normalizeSnippet(s) {
-  return s.replaceAll(/\s+/g, ' ').trim().slice(0, 180)
-}
-
-/**
- * Чи є вузол функцією.
- * @param {unknown} node AST node
- * @returns {boolean} true, якщо це будь-який вузол-функція
- */
-function isFunctionNode(node) {
-  return (
-    !!node &&
-    typeof node === 'object' &&
-    typeof node.type === 'string' &&
-    (node.type === 'FunctionDeclaration' ||
-      node.type === 'FunctionExpression' ||
-      node.type === 'ArrowFunctionExpression')
-  )
-}
-
-/**
- * Рекурсивний обхід AST з предками, щоб визначати контекст (всередині функції чи ні).
- * @param {unknown} node поточний вузол
- * @param {unknown[]} ancestors масив предків від кореня до parent
- * @param {(n: Record<string, unknown>, ancestors: unknown[]) => void} visit відвідувач для вузлів з `type`
- * @returns {void}
- */
-function walkAstWithAncestors(node, ancestors, visit) {
-  if (!node || typeof node !== 'object') return
-  if (Array.isArray(node)) {
-    for (const item of node) walkAstWithAncestors(item, ancestors, visit)
-    return
-  }
-
-  const rec = /** @type {Record<string, unknown>} */ (node)
-  if (typeof rec.type === 'string') {
-    visit(rec, ancestors)
-    ancestors = [...ancestors, rec]
-  }
-
-  for (const key of Object.keys(node)) {
-    if (key === 'parent') {
-      continue
-    }
-    const v = rec[key]
-    if (v && typeof v === 'object') {
-      walkAstWithAncestors(v, ancestors, visit)
-    }
-  }
-}
-
 /**
  * Чи це `new sql.ConnectionPool(...)` або `new mssql.ConnectionPool(...)`.
  * @param {unknown} node AST node
@@ -160,48 +85,6 @@ function isRequestFactoryCall(node) {
   return !!prop && prop.type === 'Identifier' && prop.name === 'request'
 }
 
-/**
- * Чи це `.join(...)` виклик (часто використовується для динамічних списків в SQL).
- * @param {unknown} node AST node
- * @returns {boolean} true, якщо це CallExpression `*.join(...)`
- */
-function isJoinCall(node) {
-  if (!node || node.type !== 'CallExpression') return false
-  const callee = node.callee
-  if (!callee || callee.type !== 'MemberExpression') return false
-  if (callee.computed) return false
-  const prop = callee.property
-  return !!prop && prop.type === 'Identifier' && prop.name === 'join'
-}
-
-/**
- * Повертає текст quasis у TemplateLiteral (без expressions).
- * @param {unknown} template TemplateLiteral
- * @returns {string} обʼєднаний текст
- */
-function templateQuasisText(template) {
-  if (!template || template.type !== 'TemplateLiteral') return ''
-  const quasis = template.quasis
-  if (!Array.isArray(quasis) || quasis.length === 0) return ''
-  let out = ''
-  for (const q of quasis) {
-    if (!q || typeof q !== 'object') continue
-    const value = q.value
-    if (!value || typeof value !== 'object') continue
-    if (typeof value.raw === 'string') out += value.raw
-  }
-  return out
-}
-
-/**
- * Чи виглядає TemplateLiteral як SQL-контекст зі списком (IN/VALUES (...)).
- * @param {unknown} template TemplateLiteral
- * @returns {boolean} true, якщо текст містить `IN (` або `VALUES (`
- */
-function isSqlListContextTemplate(template) {
-  return SQL_LIST_CONTEXT_RE.test(templateQuasisText(template))
-}
-
 /**
  * Знаходить створення `ConnectionPool` всередині функцій.
  * @param {string} content вихідний код
@@ -307,7 +190,6 @@ export function findSharedMssqlRequestInText(content, virtualPath = 'scan.ts') {
  *
  * Цей патерн небезпечний навіть якщо зовні використовується tagged template, бо в запит
  * потрапляє “готовий шматок SQL”, а не параметризовані значення.
- *
  * @param {string} content вихідний код
  * @param {string} [virtualPath] шлях для вибору `lang`
  * @returns {{ line: number, snippet: string }[]} список порушень
@@ -371,6 +253,24 @@ function isLiteralNumericArrayExpression(node) {
   })
 }
 
+/**
+ * Чи це безпосередній виклик числового парсера (parseInt/parseFloat/Number/BigInt)
+ * або обʼєктний доступ до них (наприклад `Number.parseInt(...)`).
+ * @param {Record<string, unknown>} node AST CallExpression
+ * @returns {boolean} true, якщо callee — числовий парсер
+ */
+function isNumericParseCallExpression(node) {
+  if (node.type !== 'CallExpression') return false
+  const callee = node.callee
+  if (!callee) return false
+  if (callee.type === 'Identifier' && NUMERIC_PARSE_FN_NAMES.has(callee.name)) return true
+  if (callee.type === 'MemberExpression' && !callee.computed) {
+    const prop = callee.property
+    return !!prop && prop.type === 'Identifier' && NUMERIC_PARSE_FN_NAMES.has(prop.name)
+  }
+  return false
+}
+
 /**
  * Чи містить піддерево виклик числового парсера (parseInt/parseFloat/Number/BigInt)
  * або унарний `+` (приведення до Number). Це сигнал, що значення гарантовано числове
@@ -380,20 +280,9 @@ function isLiteralNumericArrayExpression(node) {
  */
 function subtreeHasNumericParseCall(node) {
   if (!node || typeof node !== 'object') return false
-  if (Array.isArray(node)) return node.some(subtreeHasNumericParseCall)
+  if (Array.isArray(node)) return node.some(item => subtreeHasNumericParseCall(item))
 
-  if (node.type === 'CallExpression') {
-    const callee = node.callee
-    if (callee && callee.type === 'Identifier' && NUMERIC_PARSE_FN_NAMES.has(callee.name)) {
-      return true
-    }
-    if (callee && callee.type === 'MemberExpression' && !callee.computed) {
-      const prop = callee.property
-      if (prop && prop.type === 'Identifier' && NUMERIC_PARSE_FN_NAMES.has(prop.name)) {
-        return true
-      }
-    }
-  }
+  if (isNumericParseCallExpression(node)) return true
   if (node.type === 'UnaryExpression' && node.operator === '+') return true
 
   for (const key of Object.keys(node)) {
@@ -426,7 +315,6 @@ function collectVariableDeclarators(programNode) {
  *
  * Якщо для Identifier немає видимого init (наприклад параметр функції чи import),
  * вираз вважається не парсованим — потрібен явний парсер на місці підстановки.
- *
  * @param {unknown} expr вираз з template.expressions
  * @param {Array<Record<string, unknown>>} declarators VariableDeclarator-и файлу
  * @param {Set<string>} [seen] іменa Identifier-ів, що вже трасуються (анти-цикл)
@@ -444,13 +332,7 @@ function isInListExpressionParsed(expr, declarators, seen = new Set()) {
     const inits = declarators
       .filter(d => {
         const id = d.id
-        return (
-          !!id &&
-          typeof id === 'object' &&
-          id.type === 'Identifier' &&
-          id.name === expr.name &&
-          !!d.init
-        )
+        return !!id && typeof id === 'object' && id.type === 'Identifier' && id.name === expr.name && !!d.init
       })
       .map(d => d.init)
     if (inits.length === 0) return false
@@ -461,19 +343,52 @@ function isInListExpressionParsed(expr, declarators, seen = new Set()) {
 }
 
 /**
- * Знаходить підстановки `IN (${expr})` у TemplateLiteral, де `expr` не пройшов числовий парсер.
- *
- * Навіть у безпечному `pool.request().query\`...\`` краще явно парсити значення (parseInt/
- * Number/BigInt/parseFloat) та фільтрувати NaN — це гарантує, що жодний елемент не може
- * містити SQL-метасимволи, навіть якщо колись query-функція або обгортка зміняться. У
- * небезпечних контекстах (наприклад `pool.query(String.raw\`...\`)`) це єдиний бар'єр від SQL
- * injection.
- *
- * Випадки `${arr.join(',')}` свідомо ігноруються — їх ловить
- * {@link findUnsafeMssqlDynamicSqlListInText}.
+ * Сирий текст quasi-елемента TemplateLiteral на позиції перед expressions[i].
+ * @param {unknown} q quasi-елемент TemplateLiteral
+ * @returns {string} `q.value.raw` або порожній рядок, якщо структура не підходить
+ */
+function quasiRawText(q) {
+  return q && typeof q === 'object' && q.value && typeof q.value === 'object' && typeof q.value.raw === 'string'
+    ? q.value.raw
+    : ''
+}
+
+/**
+ * Збирає порушення для одного TemplateLiteral вузла: знаходить expressions, що
+ * стоять одразу після `IN (` без числового парсера значень.
+ * @param {Record<string, unknown>} node TemplateLiteral
+ * @param {string} content вихідний код
+ * @param {Array<Record<string, unknown>>} declarators VariableDeclarator-и для трасування
+ * @param {{ line: number, snippet: string }[]} out буфер результатів
+ */
+function collectInListUnparsedFromTemplate(node, content, declarators, out) {
+  if (node.type !== 'TemplateLiteral') return
+  const quasis = node.quasis
+  const expressions = node.expressions
+  if (!Array.isArray(quasis) || !Array.isArray(expressions) || expressions.length === 0) return
+
+  for (const [i, expr] of expressions.entries()) {
+    if (!IN_PLACEHOLDER_END_RE.test(quasiRawText(quasis[i]))) continue
+    if (!expr || typeof expr !== 'object') continue
+    if (isJoinCall(expr)) continue
+    if (isInListExpressionParsed(expr, declarators)) continue
+
+    const startOffset = typeof expr.start === 'number' ? expr.start : node.start
+    out.push({
+      line: offsetToLine(content, startOffset),
+      snippet: normalizeSnippet(content.slice(node.start, node.end))
+    })
+  }
+}
+
+/**
+ * Знаходить підстановки IN (вираз) у TemplateLiteral, де вираз не пройшов числовий парсер.
  *
+ * Навіть у безпечному tagged template pool.request().query краще явно парсити значення (parseInt,
+ * Number, BigInt, parseFloat) та фільтрувати NaN. Див. також findUnsafeMssqlDynamicSqlListInText для
+ * випадків arr.join у списках.
  * @param {string} content вихідний код
- * @param {string} [virtualPath] шлях для вибору `lang`
+ * @param {string} [virtualPath] шлях для вибору мови парсера (lang)
  * @returns {{ line: number, snippet: string }[]} список порушень
  */
 export function findUnsafeMssqlInListUnparsedInText(content, virtualPath = 'scan.ts') {
@@ -490,32 +405,7 @@ export function findUnsafeMssqlInListUnparsedInText(content, virtualPath = 'scan
 
   /** @type {{ line: number, snippet: string }[]} */
   const out = []
-  walkAstWithAncestors(result.program, [], node => {
-    if (node.type !== 'TemplateLiteral') return
-    const quasis = node.quasis
-    const expressions = node.expressions
-    if (!Array.isArray(quasis) || !Array.isArray(expressions) || expressions.length === 0) return
-
-    for (let i = 0; i < expressions.length; i++) {
-      const q = quasis[i]
-      const rawText =
-        q && typeof q === 'object' && q.value && typeof q.value === 'object' && typeof q.value.raw === 'string'
-          ? q.value.raw
-          : ''
-      if (!IN_PLACEHOLDER_END_RE.test(rawText)) continue
-
-      const expr = expressions[i]
-      if (!expr || typeof expr !== 'object') continue
-      if (isJoinCall(expr)) continue
-      if (isInListExpressionParsed(expr, declarators)) continue
-
-      const startOffset = typeof expr.start === 'number' ? expr.start : node.start
-      out.push({
-        line: offsetToLine(content, startOffset),
-        snippet: normalizeSnippet(content.slice(node.start, node.end))
-      })
-    }
-  })
+  walkAstWithAncestors(result.program, [], node => collectInListUnparsedFromTemplate(node, content, declarators, out))
 
   return out
 }
@@ -528,4 +418,3 @@ export function findUnsafeMssqlInListUnparsedInText(content, virtualPath = 'scan
 export function isMssqlScanSourceFile(relativePathPosix) {
   return SOURCE_FILE_RE.test(relativePathPosix) && !relativePathPosix.endsWith('.d.ts')
 }
-

package/scripts/utils/oxlint-canonical-skeleton.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "plugins": ["unicorn", "oxc", "import", "jsdoc", "promise", "node"],
+  "jsPlugins": ["@e18e/eslint-plugin"],
+  "categories": {},
+  "rules": {},
+  "settings": {
+    "next": {
+      "rootDir": []
+    },
+    "jsdoc": {
+      "ignorePrivate": false,
+      "ignoreInternal": false,
+      "ignoreReplacesDocs": true,
+      "overrideReplacesDocs": true,
+      "augmentsExtendsReplacesDocs": false,
+      "implementsReplacesDocs": false,
+      "exemptDestructuredRootsFromChecks": false,
+      "tagNamePreference": {}
+    }
+  },
+  "env": {
+    "builtin": true
+  },
+  "globals": {},
+  "ignorePatterns": []
+}