@xano/xanoscript-language-server 11.8.4 → 11.9.0

package/parser/tests/variable_test/coverage_check.xs

@@ -0,0 +1,293 @@
+// Valide a couverture pour un assuré
+query "coverage/check" verb=GET {
+  api_group = "coverage"
+
+  input {
+    // VIN (17 caractères)
+    text vin filters=trim|upper
+
+    // Code garage (optionnel)
+    text shop_code? filters=trim|upper
+  }
+
+  stack {
+    // Recherche et validation du véhicule
+    group {
+      stack {
+        // Trouve le vehicle a partir du VIN
+        db.query vehicle {
+          where = $db.vehicle.vin == $input.vin
+          return = {type: "single"}
+          mock = {
+            "devrait retourner véhicule sans police"      : {id: 2, vin: "2HGCM82633A004353", make: "Toyota", model: "Camry", year: 2021, owner_name: "Marie Martin"}
+            "devrait échouer si VIN introuvable"          : null
+            "devrait avoir coverages vide si pas de police": {id: 2, vin: "2HGCM82633A004353", make: "Toyota", model: "Camry", year: 2021, owner_name: "Marie Martin"}
+          }
+        } as $vehicle
+
+        // Véhicule requis
+        precondition ($vehicle != null) {
+          error_type = "notfound"
+          error = "Vehicle not found with VIN: " ~ $input.vin
+        }
+
+
+        var $unused_variable {
+          value = "This variable is not used anywhere in the code"
+        }
+
+        // Réponse véhicule
+        var $vehicle_response {
+          value = {
+            vin       : $vehicle.vin
+            make      : $vehicle.make
+            model     : $vehicle.model
+            year      : $vehicle.year
+            owner_name: $vehicle.owner_name
+          }
+        }
+      }
+    }
+
+    // Recherche de la police d'assurance active
+    group {
+      stack {
+        // Police active du véhicule
+        db.query insurance_policy {
+          where = $db.insurance_policy.vehicle_id == $vehicle.id && $db.insurance_policy.status == "active"
+          return = {type: "single"}
+          mock = {
+            "devrait retourner véhicule sans police"      : null
+            "devrait avoir coverages vide si pas de police": null
+          }
+        } as $policy
+
+        // Init réponses
+        var $policy_response {
+          value = null
+        }
+
+        var $coverages_response {
+          value = []
+        }
+
+        var $claims_summary {
+          value = {total_claims: 0, recent_claims: []}
+        }
+      }
+    }
+
+    // Traitement si police active
+    conditional {
+      if ($policy != null) {
+        // Construction de la réponse police
+        group {
+          stack {
+            // Réponse police
+            var.update $policy_response {
+              value = {
+                policy_number  : $policy.policy_number
+                status         : $policy.status
+                effective_date : $policy.effective_date
+                expiration_date: $policy.expiration_date
+                insurer_name   : $policy.insurer_name
+              }
+            }
+          }
+        }
+
+        // Récupération des couvertures
+        group {
+          stack {
+            db.query policy_coverage {
+              where = $db.policy_coverage.policy_id == $policy.id
+              return = {type: "list"}
+            } as $policy_coverages
+
+            // Requête par couverture
+            foreach ($policy_coverages) {
+              each as $pc {
+                db.get coverage_type {
+                  field_name = "id"
+                  field_value = $pc.coverage_type_id
+                } as $ctype
+
+                // Objet couverture
+                var $coverage_item {
+                  value = {
+                    code          : $ctype.code
+                    name          : $ctype.name
+                    coverage_limit: $pc.coverage_limit
+                    deductible    : $pc.deductible
+                    is_active     : $pc.is_active
+                  }
+                }
+
+                // Ajout au tableau
+                array.push $coverages_response {
+                  value = $coverage_item
+                }
+              }
+            }
+          }
+        }
+
+        // Récupération et filtrage des sinistres
+        group {
+          stack {
+            // Récupère TOUS les sinistres puis filtre en code
+            db.query claim {
+              where = $db.claim.policy_id == $policy.id
+              return = {type: "list"}
+            } as $all_claims
+
+            // Total sinistres
+            var $total_claims_count {
+              value = $all_claims|count
+            }
+
+            // Date il y a 2 ans
+            var $two_years_ago {
+              value = now|transform_timestamp:"-2 years"
+            }
+
+            // Filtrage en code (au lieu de SQL)
+            var $recent_claims_list {
+              value = []
+            }
+
+            foreach ($all_claims) {
+              each as $claim {
+                // Date en timestamp
+                var $claim_date_ts {
+                  value = $claim.incident_date|to_timestamp
+                }
+
+                // ⚠️ Filtre en code - devrait être en SQL
+                conditional {
+                  if ($claim_date_ts >= $two_years_ago) {
+                    var $recent_claim_item {
+                      value = {
+                        claim_number  : $claim.claim_number
+                        incident_date : $claim.incident_date
+                        status        : $claim.status
+                        amount_claimed: $claim.amount_claimed
+                        amount_paid   : $claim.amount_paid
+                      }
+                    }
+
+                    array.push $recent_claims_list {
+                      value = $recent_claim_item
+                    }
+                  }
+                }
+              }
+            }
+
+            // Résumé sinistres
+            var.update $claims_summary {
+              value = {
+                total_claims : $total_claims_count
+                recent_claims: $recent_claims_list
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // Recherche du garage si code fourni
+    group {
+      stack {
+        var $queried_by {
+          value = null
+        }
+
+        conditional {
+          if ($input.shop_code != null && ($input.shop_code|strlen) > 0) {
+            // Récupère garage
+            db.query repair_shop {
+              where = $db.repair_shop.shop_code == $input.shop_code
+              return = {type: "single"}
+            } as $shop
+
+            // Si garage trouvé
+            conditional {
+              if ($shop != null) {
+                var.update $queried_by {
+                  value = {shop_code: $shop.shop_code, shop_name: $shop.name}
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // Construction de la réponse finale
+    group {
+      stack {
+        var $result {
+          value = {
+            vehicle       : $vehicle_response
+            policy        : $policy_response
+            coverages     : $coverages_response
+            claims_summary: $claims_summary
+          }
+        }
+
+        // Ajoute queried_by si présent
+        conditional {
+          if ($queried_by != null) {
+            var.update $result {
+              value = $result|set:"queried_by":$queried_by
+            }
+          }
+        }
+      }
+    }
+  }
+
+  response = $result
+  history = 100
+
+  test "devrait retourner véhicule sans police" {
+    input = {vin: "2HGCM82633A004353"}
+
+    expect.to_equal ($response.vehicle.vin) {
+      value = "2HGCM82633A004353"
+    }
+
+    expect.to_equal ($response.vehicle.make) {
+      value = "Toyota"
+    }
+
+    expect.to_be_null ($response.policy)
+    expect.to_be_empty ($response.coverages)
+    expect.to_equal ($response.claims_summary.total_claims) {
+      value = 0
+    }
+  }
+
+  test "devrait échouer si VIN introuvable" {
+    input = {vin: "INVALID12345678901"}
+
+    expect.to_throw {
+      exception = "ERROR_CODE_NOT_FOUND"
+    }
+  }
+
+  test "devrait avoir coverages vide si pas de police" {
+    input = {vin: "2HGCM82633A004353"}
+
+    expect.to_be_empty ($response.coverages)
+    expect.to_be_null ($response.policy)
+    expect.to_equal ($response.claims_summary.total_claims) {
+      value = 0
+    }
+
+    expect.to_be_empty ($response.claims_summary.recent_claims)
+  }
+
+  guid = "n20O4mlUR72ZWVYiGAE-QFk_ZO4"
+}

package/parser/variableScanner.js

@@ -0,0 +1,64 @@
+import { LongFormVariable,ShortFormVariable } from "../lexer/variables.js";
+import { BLACKLISTED_VARIABLE_NAMES } from "./generic/assignableVariableProperty.js";
+
+const SHORT_FORM = ShortFormVariable.name;
+const LONG_FORM = LongFormVariable.name;
+
+const BUILTIN_NAMES = new Set(BLACKLISTED_VARIABLE_NAMES.map((n) => `$${n}`));
+// Also skip $$ (temporary variable)
+BUILTIN_NAMES.add("$$");
+
+/**
+ * Scan the token stream for variable usages (ShortFormVariable and LongFormVariable tokens).
+ * Excludes tokens at declaration offsets and built-in variable names.
+ * @param {import('chevrotain').IToken[]} tokens - The token stream
+ * @param {Array<{name: string, startOffset: number | null}>} declarations - Known declaration sites
+ * @returns {Array<{name: string, startOffset: number, endOffset: number}>}
+ */
+export function scanVariableUsages(tokens, declarations) {
+  // Build set of declaration offsets to skip
+  const declOffsets = new Set();
+  for (const decl of declarations) {
+    if (decl.startOffset != null) {
+      declOffsets.add(decl.startOffset);
+    }
+  }
+
+  const usages = [];
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    const typeName = token.tokenType.name;
+
+    if (typeName === SHORT_FORM) {
+      // Skip if this is a declaration site
+      if (declOffsets.has(token.startOffset)) continue;
+      // Skip built-in variable names
+      if (BUILTIN_NAMES.has(token.image)) continue;
+
+      usages.push({
+        name: token.image,
+        startOffset: token.startOffset,
+        endOffset: token.endOffset,
+      });
+    } else if (typeName === LONG_FORM) {
+      // $var.foo → resolve to $foo
+      // Next tokens should be Dot + Identifier
+      if (i + 2 < tokens.length) {
+        const identToken = tokens[i + 2];
+        const name = `$${identToken.image}`;
+
+        // Skip if this is a declaration site (check the identifier token)
+        if (declOffsets.has(identToken.startOffset)) continue;
+
+        usages.push({
+          name,
+          startOffset: token.startOffset,
+          endOffset: identToken.endOffset,
+        });
+      }
+    }
+  }
+
+  return usages;
+}

package/parser/variableValidator.js

@@ -0,0 +1,44 @@
+import { scanVariableUsages } from "./variableScanner.js";
+
+/**
+ * Validate variable declarations vs usages.
+ * Returns undefined-variable warnings and unused-variable hints.
+ * @param {Object} symbolTable - The parser's __symbolTable
+ * @param {import('chevrotain').IToken[]} tokens - The token stream from parser.input
+ * @returns {{ warnings: Array<{message: string, startOffset: number, endOffset: number}>, hints: Array<{message: string, startOffset: number, endOffset: number}> }}
+ */
+export function validateVariables(symbolTable, tokens) {
+  const warnings = [];
+  const hints = [];
+
+  const declarations = symbolTable.varDeclarations || [];
+  const declaredNames = new Set(declarations.map((d) => d.name));
+
+  const usages = scanVariableUsages(tokens, declarations);
+  const usedNames = new Set(usages.map((u) => u.name));
+
+  // Undefined: used but not declared
+  for (const usage of usages) {
+    if (!declaredNames.has(usage.name)) {
+      warnings.push({
+        message: `Unknown variable '${usage.name}'`,
+        startOffset: usage.startOffset,
+        endOffset: usage.endOffset,
+      });
+    }
+  }
+
+  // Unused: declared but never used
+  for (const decl of declarations) {
+    if (decl.startOffset == null) continue;
+    if (!usedNames.has(decl.name)) {
+      hints.push({
+        message: `Variable '${decl.name}' is declared but never used`,
+        startOffset: decl.startOffset,
+        endOffset: decl.endOffset,
+      });
+    }
+  }
+
+  return { warnings, hints };
+}

package/parser/variableValidator.spec.js

@@ -0,0 +1,179 @@
+import { expect } from "chai";
+import { readFileSync } from "fs";
+import { before, describe, it } from "mocha";
+import { lexDocument } from "../lexer/lexer.js";
+import { xanoscriptParser } from "./parser.js";
+import { scanVariableUsages } from "./variableScanner.js";
+import { validateVariables } from "./variableValidator.js";
+
+describe("variable tracking - coverage_check.xs", () => {
+  let varDeclarations;
+  let usages;
+  let result;
+  let text;
+
+  before(() => {
+    text = readFileSync(
+      new URL("./tests/variable_test/coverage_check.xs", import.meta.url),
+      "utf8",
+    );
+    const lexResult = lexDocument(text);
+    const parser = xanoscriptParser(text);
+    expect(parser.errors).to.be.empty;
+    varDeclarations = [...parser.__symbolTable.varDeclarations];
+    usages = scanVariableUsages(lexResult.tokens, varDeclarations);
+    result = validateVariables(parser.__symbolTable, lexResult.tokens);
+  });
+
+  function lineOf(offset) {
+    return text.substring(0, offset).split("\n").length;
+  }
+
+  function declLines(name) {
+    return varDeclarations
+      .filter((d) => d.name === name)
+      .map((d) => lineOf(d.startOffset));
+  }
+
+  function usageLines(name) {
+    return usages.filter((u) => u.name === name).map((u) => lineOf(u.startOffset));
+  }
+
+  // --- Declarations: each variable should be declared exactly once ---
+
+  it("$vehicle declared once at line 26 via 'as $vehicle'", () => {
+    expect(declLines("$vehicle")).to.deep.equal([26]);
+  });
+
+  it("$unused_variable declared once at line 35 via 'var'", () => {
+    expect(declLines("$unused_variable")).to.deep.equal([35]);
+  });
+
+  it("$vehicle_response declared once at line 40 via 'var'", () => {
+    expect(declLines("$vehicle_response")).to.deep.equal([40]);
+  });
+
+  it("$policy declared once at line 63 via 'as $policy'", () => {
+    expect(declLines("$policy")).to.deep.equal([63]);
+  });
+
+  it("$policy_response declared once at line 66 via 'var' (NOT again at line 87 via var.update)", () => {
+    expect(declLines("$policy_response")).to.deep.equal([66]);
+  });
+
+  it("$coverages_response declared once at line 70 via 'var'", () => {
+    expect(declLines("$coverages_response")).to.deep.equal([70]);
+  });
+
+  it("$claims_summary declared once at line 74 via 'var' (NOT again at line 188 via var.update)", () => {
+    expect(declLines("$claims_summary")).to.deep.equal([74]);
+  });
+
+  it("$policy_coverages declared once at line 105 via 'as'", () => {
+    expect(declLines("$policy_coverages")).to.deep.equal([105]);
+  });
+
+  it("$pc declared once at line 109 via 'each as $pc'", () => {
+    expect(declLines("$pc")).to.deep.equal([109]);
+  });
+
+  it("$ctype declared once at line 113 via 'as $ctype'", () => {
+    expect(declLines("$ctype")).to.deep.equal([113]);
+  });
+
+  it("$coverage_item declared once at line 116 via 'var'", () => {
+    expect(declLines("$coverage_item")).to.deep.equal([116]);
+  });
+
+  it("$all_claims declared once at line 142 via 'as'", () => {
+    expect(declLines("$all_claims")).to.deep.equal([142]);
+  });
+
+  it("$total_claims_count declared once at line 145 via 'var'", () => {
+    expect(declLines("$total_claims_count")).to.deep.equal([145]);
+  });
+
+  it("$two_years_ago declared once at line 150 via 'var'", () => {
+    expect(declLines("$two_years_ago")).to.deep.equal([150]);
+  });
+
+  it("$recent_claims_list declared once at line 155 via 'var'", () => {
+    expect(declLines("$recent_claims_list")).to.deep.equal([155]);
+  });
+
+  it("$claim declared once at line 160 via 'each as $claim'", () => {
+    expect(declLines("$claim")).to.deep.equal([160]);
+  });
+
+  it("$claim_date_ts declared once at line 162 via 'var'", () => {
+    expect(declLines("$claim_date_ts")).to.deep.equal([162]);
+  });
+
+  it("$recent_claim_item declared once at line 169 via 'var'", () => {
+    expect(declLines("$recent_claim_item")).to.deep.equal([169]);
+  });
+
+  it("$queried_by declared once at line 202 via 'var' (NOT again at line 217 via var.update)", () => {
+    expect(declLines("$queried_by")).to.deep.equal([202]);
+  });
+
+  it("$shop declared once at line 212 via 'as'", () => {
+    expect(declLines("$shop")).to.deep.equal([212]);
+  });
+
+  it("$result declared once at line 230 via 'var' (NOT again at line 242 via var.update)", () => {
+    expect(declLines("$result")).to.deep.equal([230]);
+  });
+
+  // --- Usages: var.update targets count as usages ---
+
+  it("$vehicle used at lines 29, 42-46, 57", () => {
+    expect(usageLines("$vehicle")).to.deep.equal([29, 42, 43, 44, 45, 46, 57]);
+  });
+
+  it("$policy_response used at line 87 (var.update) and 233", () => {
+    expect(usageLines("$policy_response")).to.include(87);
+    expect(usageLines("$policy_response")).to.include(233);
+  });
+
+  it("$claims_summary used at line 188 (var.update) and 235", () => {
+    expect(usageLines("$claims_summary")).to.include(188);
+    expect(usageLines("$claims_summary")).to.include(235);
+  });
+
+  it("$queried_by used at line 217 (var.update), 241, 243", () => {
+    expect(usageLines("$queried_by")).to.include(217);
+    expect(usageLines("$queried_by")).to.include(241);
+    expect(usageLines("$queried_by")).to.include(243);
+  });
+
+  it("$result used at line 242 (var.update), 243, 251", () => {
+    expect(usageLines("$result")).to.include(242);
+    expect(usageLines("$result")).to.include(243);
+    expect(usageLines("$result")).to.include(251);
+  });
+
+  it("$coverages_response used at lines 127 and 234", () => {
+    expect(usageLines("$coverages_response")).to.include(127);
+    expect(usageLines("$coverages_response")).to.include(234);
+  });
+
+  it("$pc used at lines 112, 120-122", () => {
+    expect(usageLines("$pc")).to.deep.equal([112, 120, 121, 122]);
+  });
+
+  it("$claim used at lines 163, 171-175", () => {
+    expect(usageLines("$claim")).to.deep.equal([163, 171, 172, 173, 174, 175]);
+  });
+
+  // --- Validation results ---
+
+  it("should produce zero undefined-variable warnings", () => {
+    expect(result.warnings).to.be.empty;
+  });
+
+  it("should flag only $unused_variable as unused", () => {
+    expect(result.hints).to.have.lengthOf(1);
+    expect(result.hints[0].message).to.include("$unused_variable");
+  });
+});