@nitra/cursor 1.8.147 → 1.8.151

package/scripts/utils/bun-sql-scan.mjs

@@ -15,110 +15,168 @@
  * Якщо файл не парситься / містить синтаксичні помилки — повертаємо порожній
  * результат: спочатку треба полагодити синтаксис, потім перезапустити перевірку.
  */
-import { parseSync } from 'oxc-parser'
+import {
+  isFunctionNode,
+  isJoinCall,
+  isSqlListContextTemplate,
+  normalizeSnippet,
+  offsetToLine,
+  parseProgramOrNull,
+  walkAstWithAncestors
+} from './ast-scan-utils.mjs'
 
 const SOURCE_FILE_RE = /\.([cm]?[jt]sx?)$/u
-const SQL_LIST_CONTEXT_RE = /\b(in|values)\b\s*\(/iu
 const BUN_SQL_IMPORT_RE = /\bimport\s*\{[\s\S]*?\b(sql|SQL)\b[\s\S]*?\}\s*from\s*["']bun["']/u
+const IN_PLACEHOLDER_END_RE = /\bin\s*(\(\s*)?$/iu
 
 /**
- * Мова для Oxc за шляхом файлу (розширення).
- * @param {string} filePath віртуальний або реальний шлях до файлу
- * @returns {'js' | 'jsx' | 'ts' | 'tsx'} значення опції `lang` для `parseSync`
+ * @param {unknown} node AST node
+ * @param {string} name імʼя змінної
+ * @returns {boolean} true, якщо це MemberExpression `${name}.length`
  */
-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'
+function isLengthMember(node, name) {
+  return (
+    !!node &&
+    typeof node === 'object' &&
+    node.type === 'MemberExpression' &&
+    !node.computed &&
+    node.object &&
+    node.object.type === 'Identifier' &&
+    node.object.name === name &&
+    node.property &&
+    node.property.type === 'Identifier' &&
+    node.property.name === 'length'
+  )
 }
 
 /**
- * Номер рядка (1-based) за зміщенням у буфері.
- * @param {string} content повний текст файлу
- * @param {number} offset байтове зміщення початку фрагмента
- * @returns {number} номер рядка від 1
+ * @param {unknown} node AST node
+ * @returns {boolean} true, якщо це числовий 0-літерал
  */
-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
+function isZeroNumberLiteral(node) {
+  return (
+    !!node &&
+    typeof node === 'object' &&
+    ((node.type === 'NumericLiteral' && node.value === 0) || (node.type === 'Literal' && node.value === 0))
+  )
 }
 
 /**
- * Стискає пробіли для повідомлення про порушення.
- * @param {string} s фрагмент коду
- * @returns {string} скорочений однорядковий рядок
+ * @param {unknown} node AST node
+ * @returns {boolean} true, якщо це Identifier з імʼям `sql`
  */
-function normalizeSnippet(s) {
-  return s.replaceAll(/\s+/gu, ' ').trim().slice(0, 180)
+function isSqlHelperIdentifier(node) {
+  return !!node && typeof node === 'object' && node.type === 'Identifier' && node.name === 'sql'
 }
 
 /**
- * Чи є вузол функцією.
- * @param {unknown} node AST node
- * @returns {boolean} true, якщо це будь-який вузол-функція
+ * Витягає імʼя змінної списку для `IN ...`:
+ * - `${ids}` → `ids`
+ * - `${sql(ids)}` → `ids`
+ * @param {unknown} expr template expression
+ * @returns {{ name: string } | { error: 'not_var' } | { error: 'sql_helper_not_var' }} імʼя змінної або причина відмови
  */
-function isFunctionNode(node) {
-  return (
-    !!node &&
-    typeof node === 'object' &&
-    typeof node.type === 'string' &&
-    (node.type === 'FunctionDeclaration' ||
-      node.type === 'FunctionExpression' ||
-      node.type === 'ArrowFunctionExpression')
-  )
+function extractInListVarNameFromExpr(expr) {
+  if (!expr || typeof expr !== 'object') return { error: 'not_var' }
+  if (expr.type === 'Identifier' && typeof expr.name === 'string') return { name: expr.name }
+
+  if (expr.type === 'CallExpression' && isSqlHelperIdentifier(expr.callee)) {
+    const args = expr.arguments
+    if (!Array.isArray(args) || args.length === 0) return { error: 'sql_helper_not_var' }
+    const first = args[0]
+    if (first && typeof first === 'object' && first.type === 'Identifier' && typeof first.name === 'string') {
+      return { name: first.name }
+    }
+    return { error: 'sql_helper_not_var' }
+  }
+
+  return { error: 'not_var' }
 }
 
 /**
- * Рекурсивний обхід AST з предками, щоб визначати контекст (всередині функції чи ні).
- * @param {unknown} node поточний вузол
- * @param {unknown[]} ancestors масив предків від кореня до parent
- * @param {(n: Record<string, unknown>, ancestors: unknown[]) => void} visit відвідувач для вузлів з `type`
- * @returns {void}
+ * Чи містить тест if-умови перевірку “список порожній”.
+ * Підтримує базові форми:
+ * - `if (!ids.length) ...`
+ * - `if (ids.length === 0) ...` / `<= 0` / `< 1`
+ * @param {unknown} test IfStatement.test
+ * @param {string} name імʼя змінної списку
+ * @returns {boolean} true, якщо це перевірка на пустоту списку
  */
-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
+function isEmptyListTest(test, name) {
+  if (!test || typeof test !== 'object') return false
+
+  if (test.type === 'UnaryExpression' && test.operator === '!') {
+    const arg = test.argument
+    if (!arg || typeof arg !== 'object') return false
+    return isLengthMember(arg, name)
   }
 
-  const rec = /** @type {Record<string, unknown>} */ (node)
-  if (typeof rec.type === 'string') {
-    visit(rec, ancestors)
-    ancestors = [...ancestors, rec]
+  if (test.type === 'BinaryExpression') {
+    const { left, right, operator } = test
+    if (!['===', '==', '<=', '<'].includes(operator)) return false
+    if (isLengthMember(left, name) && isZeroNumberLiteral(right)) return true
+    // допускаємо `0 === ids.length` теж
+    if (isZeroNumberLiteral(left) && isLengthMember(right, name) && (operator === '===' || operator === '==')) return true
   }
 
-  for (const key of Object.keys(node)) {
-    if (key === 'parent') continue
-    const v = rec[key]
-    if (v && typeof v === 'object') {
-      walkAstWithAncestors(v, ancestors, visit)
-    }
+  return false
+}
+
+/**
+ * Чи є в consequent (або в його BlockStatement) ThrowStatement.
+ * @param {unknown} consequent IfStatement.consequent
+ * @returns {boolean} true, якщо consequent містить throw
+ */
+function consequentHasThrow(consequent) {
+  if (!consequent || typeof consequent !== 'object') return false
+  if (consequent.type === 'ThrowStatement') return true
+  if (consequent.type === 'BlockStatement' && Array.isArray(consequent.body)) {
+    return consequent.body.some(s => s && typeof s === 'object' && s.type === 'ThrowStatement')
   }
+  return false
 }
 
 /**
- * Парсить файл та повертає program або null, якщо є синтаксичні помилки.
- * @param {string} content вихідний код
- * @param {string} virtualPath шлях для вибору `lang`
- * @returns {unknown | null} `result.program` або null
+ * Шукає “guard” `if (empty) throw` перед statementIndex у межах того ж BlockStatement.
+ * @param {unknown} block BlockStatement
+ * @param {number} statementIndex індекс statement, перед яким шукаємо guard
+ * @param {string} name імʼя змінної списку
+ * @returns {boolean} true, якщо guard знайдено
+ */
+function hasEmptyGuardBefore(block, statementIndex, name) {
+  if (!block || typeof block !== 'object' || block.type !== 'BlockStatement') return false
+  const body = block.body
+  if (!Array.isArray(body)) return false
+  for (let i = 0; i < statementIndex; i++) {
+    const st = body[i]
+    if (!st || typeof st !== 'object') continue
+    if (st.type !== 'IfStatement') continue
+    if (!isEmptyListTest(st.test, name)) continue
+    if (!consequentHasThrow(st.consequent)) continue
+    return true
+  }
+  return false
+}
+
+/**
+ * Знаходить найближчий enclosing BlockStatement і statement всередині нього.
+ * @param {unknown[]} ancestors ancestors масив з walkAstWithAncestors
+ * @returns {{ block: unknown, index: number } | null} block+індекс statement або null
  */
-function parseProgramOrNull(content, virtualPath) {
-  const lang = langFromPath(virtualPath || 'scan.ts')
-  let result
-  try {
-    result = parseSync(virtualPath || 'scan.ts', content, { lang, sourceType: 'module' })
-  } catch {
-    return null
+function findEnclosingBlockAndStatementIndex(ancestors) {
+  if (!Array.isArray(ancestors) || ancestors.length === 0) return null
+
+  // statement — перший зверху вузол, який лежить у block.body
+  // шукаємо пару (block, statement), де statement ∈ block.body
+  for (let i = ancestors.length - 1; i >= 1; i--) {
+    const maybeStatement = ancestors[i]
+    const maybeBlock = ancestors[i - 1]
+    if (!maybeBlock || typeof maybeBlock !== 'object' || maybeBlock.type !== 'BlockStatement') continue
+    if (!Array.isArray(maybeBlock.body)) continue
+    const idx = maybeBlock.body.indexOf(maybeStatement)
+    if (idx !== -1) return { block: maybeBlock, index: idx }
   }
-  if (result.errors?.length) return null
-  return result.program
+  return null
 }
 
 /**
@@ -152,47 +210,6 @@ function isUnsafeCallWithInterpolatedTemplate(node) {
   return Array.isArray(expressions) && expressions.length > 0
 }
 
-/**
- * Чи це `.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' || 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} обʼєднаний raw-текст
- */
-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))
-}
-
 /**
  * Знаходить `new SQL(...)` всередині функцій (handler на кожен запит замість singleton).
  * @param {string} content вихідний код
@@ -273,6 +290,80 @@ export function findUnsafeBunSqlDynamicSqlListInText(content, virtualPath = 'sca
   return out
 }
 
+/**
+ * Збирає порушення для одного TemplateLiteral вузла: `IN ... ${...}` потребує
+ * змінної + guard `if (empty) throw`.
+ * @param {Record<string, unknown>} template TemplateLiteral
+ * @param {unknown[]} ancestors ancestors з walkAstWithAncestors
+ * @param {string} content вихідний код
+ * @param {{ line: number, snippet: string, reason: 'not_var' | 'sql_helper_not_var' | 'missing_guard', name?: string }[]} out буфер результатів
+ */
+function collectInListGuardViolationsFromTemplate(template, ancestors, content, out) {
+  const expressions = template.expressions
+  const quasis = template.quasis
+  if (!Array.isArray(expressions) || expressions.length === 0) return
+  if (!Array.isArray(quasis) || quasis.length === 0) return
+
+  for (const [i, expr] of expressions.entries()) {
+    const q = quasis[i]
+    const raw =
+      q && typeof q === 'object' && q.value && typeof q.value === 'object' && typeof q.value.raw === 'string' ? q.value.raw : ''
+    if (!IN_PLACEHOLDER_END_RE.test(raw)) continue
+
+    const extracted = extractInListVarNameFromExpr(expr)
+    if ('error' in extracted) {
+      out.push({
+        line: offsetToLine(content, template.start),
+        snippet: normalizeSnippet(content.slice(template.start, template.end)),
+        reason: extracted.error
+      })
+      continue
+    }
+
+    const place = findEnclosingBlockAndStatementIndex(ancestors)
+    if (!place || !hasEmptyGuardBefore(place.block, place.index, extracted.name)) {
+      out.push({
+        line: offsetToLine(content, template.start),
+        snippet: normalizeSnippet(content.slice(template.start, template.end)),
+        reason: 'missing_guard',
+        name: extracted.name
+      })
+    }
+  }
+}
+
+/**
+ * Знаходить підстановки списків у `IN (...)`, які:
+ * - не винесені в окрему змінну (в `${...}` стоїть не Identifier або `sql(<non-Identifier>)`);
+ * - або винесені, але перед запитом немає перевірки на пустоту з `throw`.
+ * @param {string} content вихідний код
+ * @param {string} [virtualPath] шлях для вибору `lang`
+ * @returns {{ line: number, snippet: string, reason: 'not_var' | 'sql_helper_not_var' | 'missing_guard', name?: string }[]} список порушень
+ */
+export function findUnsafeBunSqlInListMissingEmptyGuardInText(content, virtualPath = 'scan.ts') {
+  const program = parseProgramOrNull(content, virtualPath)
+  if (!program) return []
+
+  /** @type {{ line: number, snippet: string, reason: 'not_var' | 'sql_helper_not_var' | 'missing_guard', name?: string }[]} */
+  const out = []
+
+  walkAstWithAncestors(program, [], (node, ancestors) => {
+    /** @type {unknown} */
+    let template = null
+    if (node.type === 'TemplateLiteral') {
+      template = node
+    } else if (node.type === 'TaggedTemplateExpression') {
+      template = node.quasi
+    }
+
+    if (!template || typeof template !== 'object' || template.type !== 'TemplateLiteral') return
+    if (!isSqlListContextTemplate(template)) return
+    collectInListGuardViolationsFromTemplate(template, ancestors, content, out)
+  })
+
+  return out
+}
+
 /**
  * Чи містить текст джерела імпорт імені `sql` або `SQL` з `"bun"`.
  * Скан по сирому тексту — без AST, щоб бути дешевим: викликається на кожному

package/scripts/utils/bunyan-imports.mjs

@@ -11,45 +11,11 @@
  */
 import { parseSync } from 'oxc-parser'
 
+import { langFromPath, offsetToLine } from './ast-scan-utils.mjs'
+
 const SOURCE_FILE_RE = /\.([cm]?[jt]sx?)$/
 const FORBIDDEN_MODULES = new Set(['@nitra/bunyan', 'bunyan'])
 
-/**
- * Мова для 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 фрагмент коду