flarelint 0.1.0

package/src/rules/routes.rs

@@ -0,0 +1,268 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
+use std::path::Path;
+
+use crate::diagnostics::{Diagnostic, SourceLocation};
+
+const MAX_PAGES_ROUTES_LIMIT: usize = 100;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RoutesConfig {
+    pub version: u32,
+    #[serde(default)]
+    pub include: Vec<String>,
+    #[serde(default)]
+    pub exclude: Vec<String>,
+}
+
+pub struct RoutesLinter<'a> {
+    pub file_path: &'a Path,
+    pub full_source: &'a str,
+    pub diagnostics: Vec<Diagnostic>,
+}
+
+impl<'a> RoutesLinter<'a> {
+    pub fn new(file_path: &'a Path, full_source: &'a str) -> Self {
+        Self {
+            file_path,
+            full_source,
+            diagnostics: Vec::new(),
+        }
+    }
+
+    pub fn lint(&mut self) {
+        let parsed: Result<RoutesConfig, _> = serde_json::from_str(self.full_source);
+        let config = match parsed {
+            Ok(c) => c,
+            Err(e) => {
+                let diag = Diagnostic::error(
+                    "routes/invalid-json",
+                    format!("Malformed _routes.json: {}", e),
+                    self.file_path,
+                )
+                .with_location(SourceLocation::new(1, 1, 0, 0));
+                self.diagnostics.push(diag);
+                return;
+            }
+        };
+
+        if config.version != 1 {
+            let loc = self.find_line_offset("\"version\"");
+            let diag = Diagnostic::error(
+                "routes/invalid-version",
+                format!(
+                    "Invalid version {}. Cloudflare Pages requires version: 1",
+                    config.version
+                ),
+                self.file_path,
+            )
+            .with_location(loc)
+            .with_suggestion("Set \"version\": 1", Some("\"version\": 1".to_string()));
+            self.diagnostics.push(diag);
+        }
+
+        let total_rules = config.include.len() + config.exclude.len();
+        if total_rules > MAX_PAGES_ROUTES_LIMIT {
+            let diag = Diagnostic::error(
+                "routes/exceeds-limit",
+                format!(
+                    "Total route count ({}) exceeds Cloudflare Pages limit of {} rules (include: {}, exclude: {}).",
+                    total_rules, MAX_PAGES_ROUTES_LIMIT, config.include.len(), config.exclude.len()
+                ),
+                self.file_path,
+            )
+            .with_location(SourceLocation::new(1, 1, 0, 0))
+            .with_suggestion(
+                format!("Reduce rules to <= {} by consolidating paths with wildcards (e.g. '/api/*').", MAX_PAGES_ROUTES_LIMIT),
+                None,
+            );
+            self.diagnostics.push(diag);
+        } else if total_rules >= 90 {
+            let diag = Diagnostic::warning(
+                "routes/approaching-limit",
+                format!(
+                    "Total route count ({}) is approaching the Cloudflare Pages limit of {} rules.",
+                    total_rules, MAX_PAGES_ROUTES_LIMIT
+                ),
+                self.file_path,
+            )
+            .with_location(SourceLocation::new(1, 1, 0, 0));
+            self.diagnostics.push(diag);
+        }
+
+        if config.include.is_empty() {
+            let diag = Diagnostic::error(
+                "routes/missing-include",
+                "Cloudflare Pages _routes.json requires at least 1 'include' rule (e.g. '/*').",
+                self.file_path,
+            )
+            .with_location(SourceLocation::new(1, 1, 0, 0))
+            .with_suggestion(
+                "Add '\"include\": [\"/*\"]'",
+                Some("\"include\": [\"/*\"]".to_string()),
+            );
+            self.diagnostics.push(diag);
+        }
+
+        let mut seen_includes = HashSet::new();
+        for rule in &config.include {
+            self.validate_pattern(rule);
+            if !seen_includes.insert(rule) {
+                let loc = self.find_line_offset(rule);
+                let diag = Diagnostic::warning(
+                    "routes/duplicate-rule",
+                    format!("Duplicate include rule '{}'", rule),
+                    self.file_path,
+                )
+                .with_location(loc)
+                .with_suggestion(format!("Remove duplicate rule '{}'", rule), None);
+                self.diagnostics.push(diag);
+            }
+        }
+
+        let mut seen_excludes = HashSet::new();
+        for rule in &config.exclude {
+            self.validate_pattern(rule);
+            if !seen_excludes.insert(rule) {
+                let loc = self.find_line_offset(rule);
+                let diag = Diagnostic::warning(
+                    "routes/duplicate-rule",
+                    format!("Duplicate exclude rule '{}'", rule),
+                    self.file_path,
+                )
+                .with_location(loc)
+                .with_suggestion(format!("Remove duplicate rule '{}'", rule), None);
+                self.diagnostics.push(diag);
+            }
+        }
+
+        for (i, r1) in config.include.iter().enumerate() {
+            for (j, r2) in config.include.iter().enumerate() {
+                if i != j && self.pattern_shadows(r1, r2) {
+                    let loc = self.find_line_offset(r2);
+                    let diag = Diagnostic::warning(
+                        "routes/shadowed-rule",
+                        format!(
+                            "Include rule '{}' is redundant because it is already matched by '{}'.",
+                            r2, r1
+                        ),
+                        self.file_path,
+                    )
+                    .with_location(loc)
+                    .with_suggestion(format!("Remove shadowed rule '{}'", r2), None);
+                    self.diagnostics.push(diag);
+                }
+            }
+        }
+
+        for exc in &config.exclude {
+            let matched_by_any = config
+                .include
+                .iter()
+                .any(|inc| self.pattern_matches_or_overlaps(inc, exc));
+            if !matched_by_any && !config.include.is_empty() {
+                let loc = self.find_line_offset(exc);
+                let diag = Diagnostic::warning(
+                    "routes/unmatched-exclude",
+                    format!("Exclude rule '{}' is unnecessary because no include rule matches its path prefix.", exc),
+                    self.file_path,
+                )
+                .with_location(loc)
+                .with_suggestion(format!("Remove unneeded exclude rule '{}' to save quota", exc), None);
+                self.diagnostics.push(diag);
+            }
+        }
+    }
+
+    fn validate_pattern(&mut self, pattern: &str) {
+        let loc = self.find_line_offset(pattern);
+
+        if !pattern.starts_with('/') {
+            let diag = Diagnostic::error(
+                "routes/invalid-path",
+                format!("Route pattern '{}' must start with '/'", pattern),
+                self.file_path,
+            )
+            .with_location(loc)
+            .with_suggestion(
+                format!("Prepend '/' to '/{}'", pattern.trim_start_matches('/')),
+                Some(format!("/{}", pattern)),
+            );
+            self.diagnostics.push(diag);
+            return;
+        }
+
+        if let Some(star_pos) = pattern.find('*')
+            && star_pos != pattern.len() - 1
+        {
+            let diag = Diagnostic::error(
+                    "routes/invalid-glob",
+                    format!(
+                        "Cloudflare Pages wildcards ('*') can only appear at the end of a route pattern (e.g. '/api/*'). In '{}', wildcard is at position {}.",
+                        pattern, star_pos
+                    ),
+                    self.file_path,
+                )
+                .with_location(loc)
+                .with_suggestion(
+                    "Move wildcard to the end of the prefix or use exact matching.",
+                    None,
+                );
+            self.diagnostics.push(diag);
+        }
+
+        if pattern.contains("//") {
+            let diag = Diagnostic::warning(
+                "routes/double-slash",
+                format!(
+                    "Route pattern '{}' contains consecutive slashes '//'",
+                    pattern
+                ),
+                self.file_path,
+            )
+            .with_location(loc);
+            self.diagnostics.push(diag);
+        }
+    }
+
+    fn pattern_shadows(&self, broader: &str, narrower: &str) -> bool {
+        if broader == "/*" && narrower != "/*" {
+            return true;
+        }
+        if let Some(prefix) = broader.strip_suffix("/*")
+            && narrower.starts_with(prefix)
+            && narrower != broader
+        {
+            return true;
+        }
+        false
+    }
+
+    fn pattern_matches_or_overlaps(&self, include: &str, exclude: &str) -> bool {
+        if include == "/*" {
+            return true;
+        }
+        if let Some(prefix) = include.strip_suffix("/*")
+            && exclude.starts_with(prefix)
+        {
+            return true;
+        }
+        if include == exclude {
+            return true;
+        }
+        false
+    }
+
+    fn find_line_offset(&self, query: &str) -> SourceLocation {
+        let mut offset = 0;
+
+        for (line_num, line) in (1..).zip(self.full_source.lines()) {
+            if let Some(col) = line.find(query) {
+                return SourceLocation::new(line_num, col + 1, offset + col, query.len());
+            }
+            offset += line.len() + 1;
+        }
+
+        SourceLocation::new(1, 1, 0, query.len())
+    }
+}

package/src/rules/waituntil.rs

@@ -0,0 +1,400 @@
+use oxc_ast::ast::*;
+use std::path::Path;
+
+use crate::diagnostics::Diagnostic;
+use crate::parser::{AstUnit, offset_to_location};
+
+pub struct WaitUntilLinter<'a> {
+    pub file_path: &'a Path,
+    pub full_source: &'a str,
+    pub diagnostics: Vec<Diagnostic>,
+    in_handler_scope: bool,
+    handler_ctx_name: Option<String>,
+}
+
+impl<'a> WaitUntilLinter<'a> {
+    pub fn new(file_path: &'a Path, full_source: &'a str) -> Self {
+        Self {
+            file_path,
+            full_source,
+            diagnostics: Vec::new(),
+            in_handler_scope: false,
+            handler_ctx_name: None,
+        }
+    }
+
+    pub fn lint_ast(&mut self, ast: &AstUnit<'_>) {
+        for stmt in &ast.program.body {
+            self.visit_top_level_statement(stmt, ast);
+        }
+    }
+
+    fn extract_snippet(&self, target_line: usize) -> Option<String> {
+        let lines: Vec<&str> = self.full_source.lines().collect();
+        if target_line == 0 || target_line > lines.len() {
+            return None;
+        }
+        Some(lines[target_line - 1].trim().to_string())
+    }
+
+    fn visit_top_level_statement(&mut self, stmt: &Statement<'_>, ast: &AstUnit<'_>) {
+        match stmt {
+            Statement::ExportDefaultDeclaration(export_default) => {
+                match &export_default.declaration {
+                    ExportDefaultDeclarationKind::FunctionDeclaration(func) => {
+                        self.lint_function_handler(func, "default", ast);
+                    }
+                    decl => {
+                        if let Some(Expression::ObjectExpression(obj)) = decl.as_expression() {
+                            for prop in &obj.properties {
+                                if let ObjectPropertyKind::ObjectProperty(p) = prop {
+                                    let key_name = self.get_property_key_name(&p.key);
+                                    if matches!(
+                                        key_name.as_deref(),
+                                        Some(
+                                            "fetch"
+                                                | "scheduled"
+                                                | "queue"
+                                                | "email"
+                                                | "tail"
+                                                | "trace"
+                                        )
+                                    ) {
+                                        self.lint_handler_property(
+                                            p,
+                                            key_name.as_deref().unwrap(),
+                                            ast,
+                                        );
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            Statement::ExportNamedDeclaration(export_named) => {
+                if let Some(Declaration::FunctionDeclaration(func)) = &export_named.declaration
+                    && let Some(ident) = &func.id
+                    && matches!(
+                        ident.name.as_str(),
+                        "GET"
+                            | "POST"
+                            | "PUT"
+                            | "DELETE"
+                            | "PATCH"
+                            | "ALL"
+                            | "onRequest"
+                            | "onRequestGet"
+                            | "onRequestPost"
+                    )
+                {
+                    self.lint_function_handler(func, ident.name.as_str(), ast);
+                }
+            }
+            Statement::ExpressionStatement(expr_stmt) => {
+                if let Expression::CallExpression(call) = &expr_stmt.expression
+                    && self.is_addeventlistener_fetch(call)
+                {
+                    self.lint_event_listener_call(call, ast);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn get_property_key_name(&self, key: &PropertyKey<'_>) -> Option<String> {
+        match key {
+            PropertyKey::StaticIdentifier(ident) => Some(ident.name.to_string()),
+            PropertyKey::StringLiteral(lit) => Some(lit.value.to_string()),
+            _ => None,
+        }
+    }
+
+    fn is_addeventlistener_fetch(&self, call: &CallExpression<'_>) -> bool {
+        let is_listener = if let Expression::Identifier(ident) = &call.callee {
+            ident.name == "addEventListener"
+        } else if let Some(mem) = call.callee.as_member_expression() {
+            if let Expression::Identifier(ident) = mem.object() {
+                (ident.name == "self" || ident.name == "globalThis")
+                    && mem.static_property_name() == Some("addEventListener")
+            } else {
+                false
+            }
+        } else {
+            false
+        };
+
+        if is_listener
+            && !call.arguments.is_empty()
+            && let Some(first_arg) = call.arguments.first()
+            && let Some(lit) = first_arg.as_expression().and_then(|e| match e {
+                Expression::StringLiteral(s) => Some(s),
+                _ => None,
+            })
+        {
+            return lit.value == "fetch" || lit.value == "scheduled" || lit.value == "queue";
+        }
+
+        false
+    }
+
+    fn lint_handler_property(
+        &mut self,
+        prop: &ObjectProperty<'_>,
+        handler_name: &str,
+        ast: &AstUnit<'_>,
+    ) {
+        match &prop.value {
+            Expression::FunctionExpression(func) => {
+                self.lint_function_handler(func, handler_name, ast);
+            }
+            Expression::ArrowFunctionExpression(arrow) => {
+                let ctx_name = if arrow.params.items.len() >= 3 {
+                    arrow
+                        .params
+                        .items
+                        .get(2)
+                        .and_then(|p| self.get_param_name(&p.pattern))
+                } else if arrow.params.items.len() == 1 {
+                    arrow
+                        .params
+                        .items
+                        .first()
+                        .and_then(|p| self.get_param_name(&p.pattern))
+                } else {
+                    None
+                };
+
+                let prev_in_scope = self.in_handler_scope;
+                let prev_ctx = self.handler_ctx_name.clone();
+                self.in_handler_scope = true;
+                self.handler_ctx_name = ctx_name;
+
+                for s in &arrow.body.statements {
+                    self.visit_handler_statement(s, ast);
+                }
+
+                self.in_handler_scope = prev_in_scope;
+                self.handler_ctx_name = prev_ctx;
+            }
+            _ => {}
+        }
+    }
+
+    fn get_param_name(&self, pattern: &BindingPattern<'_>) -> Option<String> {
+        match &pattern.kind {
+            BindingPatternKind::BindingIdentifier(ident) => Some(ident.name.to_string()),
+            _ => None,
+        }
+    }
+
+    fn lint_function_handler(
+        &mut self,
+        func: &Function<'_>,
+        _handler_name: &str,
+        ast: &AstUnit<'_>,
+    ) {
+        let ctx_name = if func.params.items.len() >= 3 {
+            func.params
+                .items
+                .get(2)
+                .and_then(|p| self.get_param_name(&p.pattern))
+        } else if func.params.items.len() == 1 {
+            func.params
+                .items
+                .first()
+                .and_then(|p| self.get_param_name(&p.pattern))
+        } else {
+            None
+        };
+
+        let prev_in_scope = self.in_handler_scope;
+        let prev_ctx = self.handler_ctx_name.clone();
+        self.in_handler_scope = true;
+        self.handler_ctx_name = ctx_name;
+
+        if let Some(body) = &func.body {
+            for s in &body.statements {
+                self.visit_handler_statement(s, ast);
+            }
+        }
+
+        self.in_handler_scope = prev_in_scope;
+        self.handler_ctx_name = prev_ctx;
+    }
+
+    fn lint_event_listener_call(&mut self, call: &CallExpression<'_>, ast: &AstUnit<'_>) {
+        if call.arguments.len() >= 2
+            && let Some(second_arg) = call.arguments.get(1)
+            && let Some(expr) = second_arg.as_expression()
+        {
+            match expr {
+                Expression::FunctionExpression(func) => {
+                    self.lint_function_handler(func, "eventListener", ast);
+                }
+                Expression::ArrowFunctionExpression(arrow) => {
+                    let event_name = arrow
+                        .params
+                        .items
+                        .first()
+                        .and_then(|p| self.get_param_name(&p.pattern));
+                    let prev_in_scope = self.in_handler_scope;
+                    let prev_ctx = self.handler_ctx_name.clone();
+                    self.in_handler_scope = true;
+                    self.handler_ctx_name = event_name;
+
+                    for s in &arrow.body.statements {
+                        self.visit_handler_statement(s, ast);
+                    }
+
+                    self.in_handler_scope = prev_in_scope;
+                    self.handler_ctx_name = prev_ctx;
+                }
+                _ => {}
+            }
+        }
+    }
+
+    fn is_wait_until_call(&self, call: &CallExpression<'_>) -> bool {
+        if let Some(mem) = call.callee.as_member_expression()
+            && let Some(prop_name) = mem.static_property_name()
+        {
+            return prop_name == "waitUntil";
+        }
+        false
+    }
+
+    fn visit_handler_statement(&mut self, stmt: &Statement<'_>, ast: &AstUnit<'_>) {
+        match stmt {
+            Statement::ExpressionStatement(expr_stmt) => {
+                self.check_handler_expression(
+                    &expr_stmt.expression,
+                    expr_stmt.span.start,
+                    expr_stmt.span.end,
+                    ast,
+                );
+            }
+            Statement::BlockStatement(block) => {
+                for s in &block.body {
+                    self.visit_handler_statement(s, ast);
+                }
+            }
+            Statement::IfStatement(if_stmt) => {
+                self.visit_handler_statement(&if_stmt.consequent, ast);
+                if let Some(alt) = &if_stmt.alternate {
+                    self.visit_handler_statement(alt, ast);
+                }
+            }
+            Statement::TryStatement(try_stmt) => {
+                for s in &try_stmt.block.body {
+                    self.visit_handler_statement(s, ast);
+                }
+                if let Some(h) = &try_stmt.handler {
+                    for s in &h.body.body {
+                        self.visit_handler_statement(s, ast);
+                    }
+                }
+                if let Some(f) = &try_stmt.finalizer {
+                    for s in &f.body {
+                        self.visit_handler_statement(s, ast);
+                    }
+                }
+            }
+            Statement::ForStatement(for_stmt) => {
+                self.visit_handler_statement(&for_stmt.body, ast);
+            }
+            Statement::ForInStatement(for_in) => {
+                self.visit_handler_statement(&for_in.body, ast);
+            }
+            Statement::ForOfStatement(for_of) => {
+                self.visit_handler_statement(&for_of.body, ast);
+            }
+            Statement::WhileStatement(while_stmt) => {
+                self.visit_handler_statement(&while_stmt.body, ast);
+            }
+            _ => {}
+        }
+    }
+
+    fn is_suspect_floating_promise(&self, call: &CallExpression<'_>) -> Option<String> {
+        if self.is_wait_until_call(call) {
+            return None;
+        }
+
+        match &call.callee {
+            Expression::Identifier(ident) => {
+                let name = ident.name.as_str();
+                if name == "fetch"
+                    || name.starts_with("send")
+                    || name.starts_with("log")
+                    || name.starts_with("save")
+                    || name.starts_with("track")
+                    || name.ends_with("Async")
+                {
+                    return Some(name.to_string());
+                }
+                if name != "console" && !name.starts_with("assert") {
+                    return Some(format!("{}()", name));
+                }
+            }
+            _ => {
+                if let Some(mem) = call.callee.as_member_expression()
+                    && let Some(prop) = mem.static_property_name()
+                    && matches!(
+                        prop,
+                        "put"
+                            | "get"
+                            | "delete"
+                            | "list"
+                            | "post"
+                            | "send"
+                            | "track"
+                            | "query"
+                            | "exec"
+                            | "run"
+                            | "fetch"
+                            | "write"
+                    )
+                {
+                    return Some(format!(".{}()", prop));
+                }
+            }
+        }
+
+        None
+    }
+
+    fn check_handler_expression(
+        &mut self,
+        expr: &Expression<'_>,
+        span_start: u32,
+        span_end: u32,
+        ast: &AstUnit<'_>,
+    ) {
+        if let Expression::CallExpression(call) = expr
+            && let Some(call_desc) = self.is_suspect_floating_promise(call)
+        {
+            let loc = offset_to_location(self.full_source, ast.byte_offset, span_start, span_end);
+
+            let ctx_var = self.handler_ctx_name.as_deref().unwrap_or("ctx");
+            let mut diag = Diagnostic::error(
+                "waituntil/unawaited-async",
+                format!(
+                    "Un-awaited asynchronous operation '{}' in request handler will be terminated early when the response completes.",
+                    call_desc
+                ),
+                self.file_path,
+            )
+            .with_location(loc)
+            .with_suggestion(
+                format!(
+                    "Pass promise to '{}.waitUntil(...)', or use 'await'.",
+                    ctx_var
+                ),
+                Some(format!("{}.waitUntil(...)", ctx_var)),
+            );
+            diag.code_snippet = self.extract_snippet(loc.line);
+            self.diagnostics.push(diag);
+        }
+    }
+}