sqllens 1.5.0 → 1.5.1

package/dist/completion/complete.js

@@ -131,7 +131,8 @@ function collect(doc, offset, schema) {
         // failure the bare-slot fallback covers. Its member twin: read `FROM/JOIN name [alias]`
         // pairs off the token stream and answer the matching relation's schema columns.
         if (scoped.length === 0 && schema) {
-            for (const c of qualifiedFallbackColumns(walkTokens, cfg, path.parts, schema, dialect))
+            const fallback = qualifiedFallbackColumns(walkTokens, cfg, path.parts, schema, dialect, doc.templated?.tags, doc.text);
+            for (const c of fallback)
                 add(c);
         }
     }
@@ -322,16 +323,45 @@ function qualifiedSourceColumns(scopes, ast, offset, qualParts, dialect, schema)
 /** The member-position twin of `fromRelationColumns` (#38): when the scope is empty (the dangling
  *  dot broke the FROM parse), read `FROM/JOIN name(.name)* [AS] [alias]` off the token stream and
  *  answer the columns of the ONE relation the qualifier matches — the alias when present, else the
- *  name's own trailing parts. No match (or several) answers [] — never a fabricated union. */
-function qualifiedFallbackColumns(walkTokens, cfg, qualParts, schema, dialect) {
+ *  name's own trailing parts. A templated source ({{ ref() }} c) is resolved through the provider
+ *  (relationOf), matching the qualifier to its alias — the same seam `fromRelationColumns` uses. No
+ *  match (or several) answers [] — never a fabricated union. */
+function qualifiedFallbackColumns(walkTokens, cfg, qualParts, schema, dialect, tags, text) {
     if (cfg.relationKeywordTokens.size === 0)
         return [];
     const b = resolveBehavior(dialect);
     const toks = walkTokens.filter((t) => t.channel === Token.DEFAULT_CHANNEL);
     const hits = [];
+    const colHits = (cols) => {
+        if (cols)
+            hits.push(cols.map((c) => ({ label: c.name, kind: "column", detail: c.type })));
+    };
     for (let i = 0; i + 1 < toks.length; i++) {
         if (!cfg.relationKeywordTokens.has(toks[i].type))
             continue;
+        // A templated source ({{ ref('customers') }} c) blanks to a channel-2 tag the filter drops, so
+        // the next SQL token is the ALIAS, not a relation name. Resolve the relation through the provider
+        // (relationOf) — the same seam fromRelationColumns uses — and match the qualifier to that alias;
+        // without this, the alias got read AS the relation name and columnsFor answered nothing.
+        const kw = toks[i];
+        const next = toks[i + 1];
+        const tag = tags?.find((t) => t.kind === "call" && t.tagSpan.start >= kw.start && t.tagSpan.start < next.start);
+        if (tag) {
+            if (schema instanceof DefaultTemplateProvider) {
+                let a = i + 1;
+                if (toks[a] && b.fold(toks[a].text) === "as")
+                    a++;
+                const alias = toks[a];
+                if (alias &&
+                    cfg.nameTokens.has(alias.type) &&
+                    qualParts.length === 1 &&
+                    b.fold(qualParts[0]) === b.fold(alias.text)) {
+                    const rel = schema.relationOf(callOf(tag, text));
+                    colHits(rel ? (rel.columns ?? schema.columnsFor(rel.nameParts, dialect)) : undefined);
+                }
+            }
+            continue; // templated source handled (or unresolvable) — never treat the alias as a relation name
+        }
         let j = i + 1;
         if (!toks[j] || !cfg.nameTokens.has(toks[j].type))
             continue;
@@ -352,9 +382,7 @@ function qualifiedFallbackColumns(walkTokens, cfg, qualParts, schema, dialect) {
                 qualParts.every((p, k) => b.fold(p, "table") === b.fold(parts[parts.length - qualParts.length + k], "table"));
         if (!matches)
             continue;
-        const cols = schema.columnsFor(parts, dialect);
-        if (cols)
-            hits.push(cols.map((c) => ({ label: c.name, kind: "column", detail: c.type })));
+        colHits(schema.columnsFor(parts, dialect));
     }
     return hits.length === 1 ? hits[0] : [];
 }

package/dist/symbols/symbols.js

@@ -422,7 +422,10 @@ function relationSymbol(src, frame, dialect) {
         return {
             kind: "table",
             modifiers: ref,
-            name: src.name.map(show).join("."),
+            // DISPLAY spelling, from relation.parts — NOT src.name, which is the folded identity key
+            // (#38). displaying the key uppercases the name on a case-folding dialect; matches the CTE
+            // branch's display convention and scope.d.ts's "never show name" contract.
+            name: src.source.relation.parts.map(show).join("."),
             span: spanOf(src.source.cst),
             frame,
             node: src.source,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sqllens",
-	"version": "1.5.0",
+	"version": "1.5.1",
 	"description": "A TypeScript SQL parser and static analyzer: parse, resolve names, infer types, and trace column lineage across many SQL dialects (Databricks, T-SQL, Snowflake, BigQuery, Redshift, PostgreSQL, DuckDB, Trino, SQLite, MySQL).",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",