Bruno Charest
e1a658cbcc
- Add docker-compose.test.yml for isolated testing - Add test vault with sample Markdown notes across categories - Add frontend audit script for module validation - Increment user failed_attempts in test data
419 lines
19 KiB
JavaScript
419 lines
19 KiB
JavaScript
#!/usr/bin/env node
|
|
/**
|
|
* ObsiGate — Comprehensive frontend validator.
|
|
* Scans ALL modules and catches:
|
|
* 1. Function calls without import or local definition
|
|
* 2. State variables used without state. prefix
|
|
* 3. Imported functions that don't exist in source module
|
|
* 4. Const reassignments
|
|
* Usage: node tests/frontend/audit.mjs
|
|
*/
|
|
|
|
import { readFileSync, readdirSync } from 'fs';
|
|
import { join, dirname } from 'path';
|
|
import { fileURLToPath } from 'url';
|
|
|
|
const __dirname = dirname(fileURLToPath(import.meta.url));
|
|
const JS_DIR = join(__dirname, '../../frontend/js');
|
|
|
|
let errors = [];
|
|
let warnings = [];
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════════
|
|
// Browser globals allowed without import
|
|
// ═══════════════════════════════════════════════════════════════════════════
|
|
const BROWSER_GLOBALS = new Set([
|
|
'console','document','window','fetch','localStorage','sessionStorage','navigator','location','history',
|
|
'setTimeout','clearTimeout','setInterval','clearInterval','requestAnimationFrame','cancelAnimationFrame',
|
|
'addEventListener','removeEventListener','getElementById','querySelector','querySelectorAll',
|
|
'getComputedStyle','getBoundingClientRect','createElement','createElementNS','createTextNode',
|
|
'createDocumentFragment','appendChild','removeChild','insertBefore','replaceChild','cloneNode',
|
|
'setAttribute','getAttribute','removeAttribute','hasAttribute','classList','parentElement','parentNode',
|
|
'children','childNodes','firstChild','lastChild','nextSibling','previousSibling','textContent','innerHTML',
|
|
'style','className','value','checked','focus','blur','click','preventDefault','stopPropagation',
|
|
'JSON','Math','Date','Object','Array','Map','Set','WeakMap','Promise','Symbol','RegExp','Error',
|
|
'parseInt','parseFloat','isNaN','isFinite','encodeURIComponent','decodeURIComponent','atob','btoa',
|
|
'String','Number','Boolean','Intl','devicePixelRatio','URLSearchParams','FormData','Blob','FileReader',
|
|
'Image','EventSource','WebSocket','Worker','ServiceWorker','Notification','Headers','Request','Response',
|
|
'MutationObserver','IntersectionObserver','ResizeObserver','DOMParser','CustomEvent','Event',
|
|
'KeyboardEvent','MouseEvent','WheelEvent','FocusEvent','InputEvent','ClipboardEvent','TouchEvent',
|
|
'requestFullscreen','exitFullscreen','fullscreenElement','crypto','performance','alert','confirm',
|
|
'scrollTo','scrollBy','scrollIntoView','getContext','toDataURL','normalize','dispatchEvent',
|
|
'execCommand','closest','contains','toggle','replaceChildren','remove','before','after','TextDecoder',
|
|
'TextEncoder','Uint8Array','ArrayBuffer','File','FileList','DataTransfer','matchMedia',
|
|
'structuredClone','queueMicrotask','reportError',
|
|
// lucide icons
|
|
'lucide','createIcons',
|
|
// markdown rendering
|
|
'marked','hljs','frontmatter','mistune',
|
|
// Canvas drawing
|
|
'beginPath','closePath','moveTo','lineTo','arc','fill','stroke','fillStyle','strokeStyle',
|
|
'lineWidth','font','textAlign','fillText','clearRect','measureText','setLineDash','shadowColor',
|
|
'shadowBlur','setTransform','save','restore','translate','scale','rotate','roundRect',
|
|
'getPropertyValue',
|
|
]);
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════════
|
|
// Phase 1: Parse all modules — collect exports, imports, local definitions
|
|
// ═══════════════════════════════════════════════════════════════════════════
|
|
|
|
const modules = {};
|
|
const allExports = {};
|
|
|
|
function parseModule(fileName) {
|
|
const content = readFileSync(join(JS_DIR, fileName), 'utf-8');
|
|
const lines = content.split('\n');
|
|
|
|
const info = {
|
|
imports: [], // [{ name, from }]
|
|
exports: new Set(),
|
|
localDefs: new Set(), // function names, const names defined in this file
|
|
localVars: new Set(), // let/var names
|
|
content,
|
|
lines,
|
|
};
|
|
|
|
let inExportBlock = false;
|
|
let exportBlockText = '';
|
|
let inMultiLineImport = false;
|
|
let importBlockText = '';
|
|
|
|
for (let i = 0; i < lines.length; i++) {
|
|
const line = lines[i];
|
|
const trimmed = line.trim();
|
|
|
|
// ─ Multi-line export { ... } ─
|
|
if (/^export\s*\{/.test(trimmed) && !/\}/.test(trimmed)) {
|
|
inExportBlock = true;
|
|
exportBlockText = trimmed;
|
|
continue;
|
|
}
|
|
if (inExportBlock) {
|
|
exportBlockText += ' ' + trimmed;
|
|
if (/\}/.test(trimmed)) {
|
|
inExportBlock = false;
|
|
const m = exportBlockText.match(/\{([^}]+)\}/);
|
|
if (m) {
|
|
for (const name of m[1].split(',')) {
|
|
const n = name.trim().replace(/\s+as\s+.*/, '').trim();
|
|
if (n) info.exports.add(n);
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// ─ Multi-line import { ... } ─
|
|
if (/^import\s*\{/.test(trimmed) && !/from/.test(trimmed)) {
|
|
inMultiLineImport = true;
|
|
importBlockText = trimmed;
|
|
continue;
|
|
}
|
|
if (inMultiLineImport) {
|
|
importBlockText += ' ' + trimmed;
|
|
if (/from/.test(trimmed)) {
|
|
inMultiLineImport = false;
|
|
processImportLine(importBlockText, info, fileName);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// ─ export const/let/function/async function X ─
|
|
let m = trimmed.match(/^export\s+(?:const|let|function|async\s+function|class)\s+(\w+)/);
|
|
if (m) {
|
|
info.exports.add(m[1]);
|
|
info.localDefs.add(m[1]);
|
|
continue;
|
|
}
|
|
|
|
// ─ Single-line export { a, b } ─
|
|
m = trimmed.match(/^export\s*\{([^}]+)\}/);
|
|
if (m) {
|
|
for (const name of m[1].split(',')) {
|
|
const n = name.trim().replace(/\s+as\s+.*/, '').trim();
|
|
if (n) info.exports.add(n);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// ─ export { a } from './x.js' ─
|
|
m = trimmed.match(/^export\s*\{([^}]+)\}\s*from\s*['"]\.\/(\w+\.js)['"]/);
|
|
if (m) {
|
|
for (const name of m[1].split(',')) {
|
|
const n = name.trim().replace(/\s+as\s+.*/, '').trim();
|
|
if (n) info.exports.add(n);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// ─ import { a, b } from './x.js' ─
|
|
m = trimmed.match(/^import\s*\{([^}]+)\}\s*from\s*['"]\.\/(\w+\.js)['"]/);
|
|
if (m) processImportLine(trimmed, info, fileName);
|
|
|
|
// ─ import * as NS from './x.js' ─
|
|
m = trimmed.match(/^import\s+\*\s+as\s+(\w+)\s+from\s*['"]\.\/(\w+\.js)['"]/);
|
|
if (m) {
|
|
info.imports.push({ ns: m[1], from: m[2] });
|
|
}
|
|
|
|
// ─ function / async function X ─
|
|
m = trimmed.match(/^(?:async\s+)?function\s+(\w+)/);
|
|
if (m && !trimmed.startsWith('//') && !trimmed.startsWith('*')) {
|
|
info.localDefs.add(m[1]);
|
|
}
|
|
|
|
// ─ Object method definitions: methodName() { or methodName: function ─
|
|
m = trimmed.match(/^\s+(\w+)\s*\([^)]*\)\s*\{/);
|
|
if (m && !trimmed.startsWith('//') && !trimmed.startsWith('*')) {
|
|
info.localDefs.add(m[1]);
|
|
}
|
|
m = trimmed.match(/^\s+(\w+)\s*:\s*function/);
|
|
if (m && !trimmed.startsWith('//') && !trimmed.startsWith('*')) {
|
|
info.localDefs.add(m[1]);
|
|
}
|
|
m = trimmed.match(/^\s+(\w+)\s*:\s*async\s+function/);
|
|
if (m && !trimmed.startsWith('//') && !trimmed.startsWith('*')) {
|
|
info.localDefs.add(m[1]);
|
|
}
|
|
m = trimmed.match(/^\s+(\w+)\s*:\s*\([^)]*\)\s*=>/);
|
|
if (m && !trimmed.startsWith('//') && !trimmed.startsWith('*')) {
|
|
info.localDefs.add(m[1]);
|
|
}
|
|
|
|
// ─ const X = ─
|
|
m = trimmed.match(/^const\s+(\w+)\s*=/);
|
|
if (m) {
|
|
info.localDefs.add(m[1]);
|
|
info.localVars.add(m[1]);
|
|
}
|
|
|
|
// ─ let X = ─
|
|
m = trimmed.match(/^let\s+(\w+)\s*=/);
|
|
if (m) {
|
|
info.localVars.add(m[1]);
|
|
}
|
|
}
|
|
|
|
allExports[fileName] = info.exports;
|
|
modules[fileName] = info;
|
|
}
|
|
|
|
function processImportLine(line, info, fileName) {
|
|
const m = line.match(/^import\s*\{([^}]+)\}\s*from\s*['"]\.\/(\w+\.js)['"]/);
|
|
if (!m) return;
|
|
const source = m[2];
|
|
for (const name of m[1].split(',')) {
|
|
const parts = name.trim().split(/\s+as\s+/);
|
|
const importName = parts[0].trim();
|
|
const localName = parts.length > 1 ? parts[1].trim() : importName;
|
|
info.imports.push({ name: localName, from: source });
|
|
info.localDefs.add(localName);
|
|
}
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════════
|
|
// Phase 2: Validate imports exist in source
|
|
// ═══════════════════════════════════════════════════════════════════════════
|
|
|
|
function validateImports() {
|
|
for (const [modName, info] of Object.entries(modules)) {
|
|
for (const imp of info.imports) {
|
|
if (imp.ns) {
|
|
// Namespace import — check accessed properties
|
|
const nsRegex = new RegExp(`\\b${imp.ns}\\.(\\w+)`, 'g');
|
|
let m;
|
|
while ((m = nsRegex.exec(info.content)) !== null) {
|
|
const accessed = m[1];
|
|
if (!allExports[imp.from]?.has(accessed)) {
|
|
if (!BROWSER_GLOBALS.has(accessed) && !info.localDefs.has(accessed)) {
|
|
errors.push(`${modName}: uses ${imp.ns}.${accessed} but ${imp.from} doesn't export '${accessed}'`);
|
|
}
|
|
}
|
|
}
|
|
} else if (imp.name && imp.from) {
|
|
if (!allExports[imp.from]?.has(imp.name)) {
|
|
// Check if it's a re-export from another file
|
|
let found = false;
|
|
for (const [otherMod, otherExports] of Object.entries(allExports)) {
|
|
if (otherExports.has(imp.name)) found = true;
|
|
}
|
|
if (!found) {
|
|
errors.push(`${modName}: imports '${imp.name}' from ${imp.from} but it's NOT exported there`);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════════
|
|
// JavaScript keywords that look like function calls but aren't
|
|
// ═══════════════════════════════════════════════════════════════════════════
|
|
const JS_KEYWORDS = new Set([
|
|
'if','else','for','while','do','switch','case','default','break','continue',
|
|
'return','throw','try','catch','finally','async','await','function','var',
|
|
'let','const','class','extends','super','new','delete','typeof','instanceof',
|
|
'void','yield','import','export','in','of','this','debugger','with',
|
|
'true','false','null','undefined','NaN','Infinity',
|
|
// French/English words that appear in comments/strings
|
|
'lien','entrant','fichier','passe','vue','function','var','widgets','unsupported',
|
|
'management','directory','directories','dot','container','storage','options',
|
|
'connect','interface','header','js','forces','bg','border','accent','muted','text',
|
|
'all','add','get','set','has','keys','values','entries','some','apply','update',
|
|
'load','show','hide','render','open','close','init','destroy','toggle',
|
|
'then','catch','finally','parse','stringify','log','warn','error','debug',
|
|
'now','random','max','min','abs','round','floor','ceil','sqrt','pow',
|
|
'cos','sin','log','exp','toString','toFixed','toISOString','toLocaleString',
|
|
'toLocaleDateString','toLocaleTimeString','toUpperCase','toLowerCase',
|
|
'search','test','exec','match','replace','split','join','trim','startsWith',
|
|
'endsWith','includes','indexOf','charAt','substring','slice','sort','reverse',
|
|
'map','filter','reduce','forEach','find','findIndex','push','pop','shift',
|
|
'unshift','splice','concat','every','some','flat','flatMap',
|
|
'getItem','setItem','removeItem','addEventListener','removeEventListener',
|
|
'dispatchEvent','querySelector','querySelectorAll','getElementById',
|
|
'getElementsByClassName','getElementsByTagName','createElement',
|
|
'createTextNode','appendChild','removeChild','insertBefore','replaceChild',
|
|
'setAttribute','getAttribute','removeAttribute','classList',
|
|
'getBoundingClientRect','getComputedStyle','requestAnimationFrame',
|
|
'parseInt','parseFloat','isNaN','isFinite',
|
|
'disconnect','observe','unobserve','compareDocumentPosition',
|
|
'preventDefault','stopPropagation','stopImmediatePropagation',
|
|
'writeText','execCommand','createIcons','getContext','toDataURL',
|
|
'setTransform','beginPath','closePath','moveTo','lineTo','arc','fill','stroke',
|
|
'save','restore','translate','scale','rotate','clearRect','fillText',
|
|
'setLineDash','measureText','getPropertyValue','focus','blur','click',
|
|
'setTimeout','clearTimeout','setInterval','clearInterval',
|
|
'encodeURIComponent','decodeURIComponent',
|
|
'getRecentEvents','getState','getConfig','getMenuData','getVaultIcon',
|
|
'patternToRegex','isTagFiltered','fmtSize','localCompare',
|
|
'fromCharCode','codePointAt','normalize','padStart','padEnd','repeat',
|
|
'createRange','surroundContents','getClientRects',
|
|
'switch','declare','module','require',
|
|
]);
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════════
|
|
// Phase 3: Find function calls and variable refs without import/definition
|
|
// ═══════════════════════════════════════════════════════════════════════════
|
|
|
|
// State variable names that MUST use state. prefix
|
|
const STATE_VARS = new Set([
|
|
'APP_VERSION','currentVault','currentPath','allVaults','selectedContextVault',
|
|
'searchTimeout','searchAbortController','advancedSearchOffset','advancedSearchTotal',
|
|
'advancedSearchSort','advancedSearchLastQuery','suggestAbortController',
|
|
'dropdownActiveIndex','dropdownItems','currentSearchId','selectedTags',
|
|
'searchCaseSensitive','searchWholeWord','searchRegex','searchFilterVisible',
|
|
'SEARCH_HISTORY_KEY','MAX_HISTORY_ENTRIES','SUGGEST_DEBOUNCE_MS',
|
|
'ADVANCED_SEARCH_LIMIT','MIN_SEARCH_LENGTH','SEARCH_TIMEOUT_MS',
|
|
'showingSource','cachedRawSource','editorView','editorVault','editorPath',
|
|
'fallbackEditorEl','_iconDebounceTimer','outlineObserver','activeHeadingId',
|
|
'headingsCache','rightSidebarVisible','rightSidebarWidth',
|
|
'sidebarFilterCaseSensitive','activeSidebarTab','filterDebounce','vaultSettings',
|
|
]);
|
|
|
|
function findUndefinedRefs(modName) {
|
|
const info = modules[modName];
|
|
if (!info) return;
|
|
|
|
// Build "available" set: imported names + locally defined + browser globals
|
|
const available = new Set([...info.localDefs, ...BROWSER_GLOBALS]);
|
|
|
|
// Also add imported namespace prefixes
|
|
for (const imp of info.imports) {
|
|
if (imp.ns) available.add(imp.ns);
|
|
}
|
|
|
|
// Scan for standalone identifiers used as function calls or variable refs
|
|
const content = info.content;
|
|
|
|
// Find all identifiers that look like function calls or property access
|
|
// Pattern: word(
|
|
const callRegex = /\b([a-zA-Z_$][\w$]*)\s*\(/g;
|
|
let m;
|
|
const checkedLines = new Set();
|
|
|
|
while ((m = callRegex.exec(content)) !== null) {
|
|
const name = m[1];
|
|
if (available.has(name)) continue;
|
|
if (JS_KEYWORDS.has(name)) continue;
|
|
if (name[0] === name[0].toUpperCase() && name[0] !== '_') continue; // skip classes/types
|
|
|
|
// Get the line for context
|
|
const lineNum = content.substring(0, m.index).split('\n').length;
|
|
if (checkedLines.has(`${name}:${lineNum}`)) continue;
|
|
checkedLines.add(`${name}:${lineNum}`);
|
|
|
|
// Skip if it's a method call like .name(
|
|
const before = content.substring(Math.max(0, m.index - 1), m.index);
|
|
if (before === '.') continue;
|
|
|
|
// Skip if it's inside a string or comment
|
|
const lineStart = content.lastIndexOf('\n', m.index) + 1;
|
|
const lineEnd = content.indexOf('\n', m.index);
|
|
const line = content.substring(lineStart, lineEnd > 0 ? lineEnd : content.length);
|
|
if (line.trim().startsWith('//') || line.trim().startsWith('*')) continue;
|
|
|
|
errors.push(`${modName}:${lineNum} — '${name}()' called but not imported or defined`);
|
|
}
|
|
|
|
// Also check for bare state variable references (without state. prefix)
|
|
for (const varName of STATE_VARS) {
|
|
const bareRegex = new RegExp(`(?<!\\.)(?<!state\\.)\\b${varName}\\b`, 'g');
|
|
let bm;
|
|
while ((bm = bareRegex.exec(content)) !== null) {
|
|
// Skip import/export lines
|
|
const lineStart = content.lastIndexOf('\n', bm.index) + 1;
|
|
const line = content.substring(lineStart, content.indexOf('\n', bm.index));
|
|
if (line.match(/^\s*(import|export)\s/)) continue;
|
|
// Skip if this file IS state.js
|
|
if (modName === 'state.js') continue;
|
|
// Skip if it's inside a string
|
|
const lineNum = content.substring(0, bm.index).split('\n').length;
|
|
errors.push(`${modName}:${lineNum} — '${varName}' used without state. prefix`);
|
|
}
|
|
}
|
|
|
|
// Check for const reassignments of imported names
|
|
for (const imp of info.imports) {
|
|
if (imp.ns || !imp.name) continue;
|
|
const reassignRegex = new RegExp(`^\\s*${imp.name}\\s*=\\s*[^=]`, 'gm');
|
|
let rm;
|
|
while ((rm = reassignRegex.exec(content)) !== null) {
|
|
const lineNum = content.substring(0, rm.index).split('\n').length;
|
|
errors.push(`${modName}:${lineNum} — imported '${imp.name}' is reassigned (const violation)`);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════════
|
|
// Run
|
|
// ═══════════════════════════════════════════════════════════════════════════
|
|
|
|
const files = readdirSync(JS_DIR).filter(f => f.endsWith('.js') && f !== 'sidebar_raw.js');
|
|
|
|
for (const file of files) {
|
|
parseModule(file);
|
|
}
|
|
|
|
validateImports();
|
|
|
|
for (const file of files) {
|
|
findUndefinedRefs(file);
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════════
|
|
// Report
|
|
// ═══════════════════════════════════════════════════════════════════════════
|
|
|
|
if (errors.length > 0) {
|
|
console.error(`\n❌ ${errors.length} frontend error(s) found:\n`);
|
|
for (const err of errors) {
|
|
console.error(` • ${err}`);
|
|
}
|
|
console.error(`\n💡 Fix: add missing imports, exports, or state. prefixes`);
|
|
process.exit(1);
|
|
} else {
|
|
const totalExports = Object.values(allExports).reduce((s, e) => s + e.size, 0);
|
|
console.log(`\n✅ ${files.length} modules, ${totalExports} exports — 0 issues`);
|
|
process.exit(0);
|
|
}
|