sqllens 1.0.0 → 1.2.0

package/dist/qualify/template-provider.js

@@ -18,15 +18,16 @@
 // overrides only the parts it knows (manifest lookups, var values, shape
 // classification) and inherits the conservative default for the rest.
 //
-// The default provider also carries the DBT-BUILTIN knowledge that used to be
-// hardcoded inside the segmenter (NO_OUTPUT_BUILTINS / SHAPE_EXCLUDED string
-// sets): `config`/`docs`/`print`/`log`/`return`/`exceptions` produce nothing;
-// `ref`/`source` produce a relation logically named by their literal args;
-// `env_var` produces a string. Domain knowledge lives in the provider; the
-// ENGINE keeps only the positional machinery (length-/newline-preserving
-// fills, slot guards, statement-slot handling) — non-overridable on purpose: a
-// provider states WHAT a call produces, never how it is spliced, so a buggy
-// provider can make meanings unknown but can never corrupt a parse.
+// The DBT-BUILTIN knowledge (config/docs/print/log/return/exceptions produce
+// nothing; ref/source produce a relation logically named by their literal args;
+// env_var produces a string) is NOT minijinja knowledge and does NOT live in the
+// neutral default: it lives in `DbtTemplateProvider` (below), the shipped dbt
+// overlay a consumer extends. The neutral `DefaultTemplateProvider` knows no
+// macro vocabulary at all. Domain knowledge lives in the provider; the ENGINE
+// keeps only the positional machinery (length-/newline-preserving fills, slot
+// guards, statement-slot handling) — non-overridable on purpose: a provider
+// states WHAT a call produces, never how it is spliced, so a buggy provider can
+// make meanings unknown but can never corrupt a parse.
 //
 // Contract points (agreed on the channel):
 //   - SYNC-ONLY: every method answers from a warm cache; misses are recorded
@@ -106,39 +107,21 @@ export class DefaultTemplateProvider {
         return this._version;
     }
     // --- Granular expansion knowledge (the C#-style virtuals — override the parts you know). ---
-    /** The relation a call produces. Default knowledge: `ref(...)` → the dbt-LOGICAL model name,
-     *  `source(a,b)` → the logical [source, table] — literal args only, never fabricated. An
-     *  overriding provider answers the PHYSICAL relation (+columns) from its manifest/describe. */
-    relationOf(call) {
-        if (call.packageParts !== undefined)
-            return undefined;
-        if (call.name === "ref") {
-            const model = refModel(call);
-            return typeof model === "string" ? { nameParts: [model] } : undefined;
-        }
-        if (call.name === "source") {
-            const parts = sourceParts(call);
-            if (parts && typeof parts[0] === "string" && typeof parts[1] === "string") {
-                return { nameParts: [parts[0], parts[1]] };
-            }
-        }
+    /** The relation a call produces. The NEUTRAL floor knows no macro vocabulary, so it answers
+     *  undefined for everything: `ref`/`source` are dbt macros, not minijinja knowledge, and live in
+     *  `DbtTemplateProvider`. An overriding provider answers the relation (+columns) it knows. */
+    relationOf(_call) {
         return undefined;
     }
-    /** The scalar value a call yields. Default knowledge: `env_var` returns a string (dbt docs);
-     *  `var` and user macros are unknown. */
-    valueOf(call) {
-        if (call.packageParts === undefined && call.name === "env_var")
-            return { type: "string" };
+    /** The scalar value a call yields. Neutral floor: unknown (no macro vocabulary). `env_var` is a
+     *  dbt builtin known by `DbtTemplateProvider`. */
+    valueOf(_call) {
         return undefined;
     }
-    /** The rendered-output shape of a call. Default knowledge: the no-output builtins → "nothing".
-     *  Everything else unknown (the engine derives a shape from stronger fields, or falls back to
-     *  its positional fill). */
-    shapeOf(call) {
-        if (call.packageParts === undefined && NO_OUTPUT_BUILTINS.has(call.name))
-            return "nothing";
-        if (call.packageParts !== undefined && NO_OUTPUT_BUILTINS.has(call.packageParts[0] ?? ""))
-            return "nothing";
+    /** The rendered-output shape of a call. Neutral floor: unknown (the engine derives a shape from
+     *  stronger fields, or falls back to its positional fill). The dbt no-output builtins → "nothing"
+     *  is `DbtTemplateProvider` knowledge. */
+    shapeOf(_call) {
         return undefined;
     }
     /** The columns a column-list-producing macro emits. Default: unknown. */
@@ -149,6 +132,15 @@ export class DefaultTemplateProvider {
     collectionOf(_call) {
         return undefined;
     }
+    /** Completion candidates for a template call slot: the caret sits in `callee`'s positional argument
+     *  `argIndex` (a dbt ref's arg 0 answers the model names, a source's arg 0 the source names, arg 1
+     *  the table names). `argIndex` is -1 when the caret is still in the callee name itself, so a host
+     *  can answer the macro/callee names it knows. `packageName` is the dotted package (`dbt_utils` in
+     *  `dbt_utils.star(...)`). The NEUTRAL provider knows no vocabulary and offers none; a host answers
+     *  from its catalog. `completeAt` reads this when the caret is inside a jinja tag. */
+    templateCandidates(_callee, _argIndex, _packageName) {
+        return [];
+    }
     // --- The composed entry the ENGINE consults (rarely overridden wholesale). ---
     /**
      * Everything known about `call`, composed from the granular methods. Field precedence for the
@@ -257,6 +249,45 @@ export class DefaultTemplateProvider {
         return anyNew;
     }
 }
+/**
+ * The shipped dbt overlay: a `DefaultTemplateProvider` that knows dbt's built-in macros and nothing
+ * more. `ref(...)` resolves to the dbt-LOGICAL model name, `source(a,b)` to the logical
+ * [source, table], `env_var` to a string, and the no-output builtins
+ * (config/docs/print/log/return/exceptions) render nothing. Static famous-macro knowledge ONLY: no
+ * manifest, no warehouse, no project config, no runtime. A dbt consumer with runtime knowledge
+ * extends THIS (not the neutral `DefaultTemplateProvider`) and overrides the granular methods with
+ * what its manifest / describe cache resolve to. This class is where the dbt vocabulary lives so the
+ * neutral core and default do not carry it.
+ */
+export class DbtTemplateProvider extends DefaultTemplateProvider {
+    relationOf(call) {
+        if (call.packageParts !== undefined)
+            return undefined;
+        if (call.name === "ref") {
+            const model = refModel(call);
+            return typeof model === "string" ? { nameParts: [model] } : undefined;
+        }
+        if (call.name === "source") {
+            const parts = sourceParts(call);
+            if (parts && typeof parts[0] === "string" && typeof parts[1] === "string") {
+                return { nameParts: [parts[0], parts[1]] };
+            }
+        }
+        return undefined;
+    }
+    valueOf(call) {
+        if (call.packageParts === undefined && call.name === "env_var")
+            return { type: "string" };
+        return undefined;
+    }
+    shapeOf(call) {
+        if (call.packageParts === undefined && NO_OUTPUT_BUILTINS.has(call.name))
+            return "nothing";
+        if (call.packageParts !== undefined && NO_OUTPUT_BUILTINS.has(call.packageParts[0] ?? ""))
+            return "nothing";
+        return undefined;
+    }
+}
 /**
  * The ONE shared no-configuration default — an OPEN world that answers nothing and diagnoses
  * nothing. Sharing a single instance across documents/calls is safe ONLY because the bare base

package/dist/redshift/behavior.d.ts

@@ -0,0 +1,2 @@
+import type { DialectBehavior } from "../dialect-behavior/behavior.js";
+export declare const redshiftBehavior: DialectBehavior;

package/dist/redshift/behavior.js

@@ -0,0 +1,19 @@
+import { acceptsFor } from "../dialect-behavior/coerce-rules.js";
+import { likePatternToRegExp } from "../scope/like-pattern.js";
+import { SIGNATURES } from "../signature/signatures.js";
+import { displayName, fold, foldTableName, matchesSourceKey } from "./fold.js";
+import { redshiftLiteral, redshiftParseType, REDSHIFT_FUNCTION_RETURNS } from "./infer.js";
+export const redshiftBehavior = {
+    fold,
+    displayName,
+    foldTableName,
+    matchesSourceKey,
+    likeMatch: (pattern, value) => likePatternToRegExp(pattern).test(value),
+    literal: redshiftLiteral,
+    parseType: redshiftParseType,
+    functions: REDSHIFT_FUNCTION_RETURNS,
+    division: "integer",
+    signatures: SIGNATURES.redshift,
+    // Redshift implicit coercion: VARCHAR containing a number coerces to numeric (STR_TO_NUM=true), no bool<->num (BOOL_NUM=false).
+    accepts: (argType, paramText) => acceptsFor(redshiftParseType, true, false, argType, paramText),
+};

package/dist/redshift/fold.d.ts

@@ -0,0 +1,8 @@
+import { type FoldRule, type IdentKind } from "../ident/fold.js";
+export declare const REDSHIFT_FOLD_RULE: FoldRule;
+/** Fold an identifier to its Redshift identity key. */
+export declare function fold(raw: string, kind?: IdentKind): string;
+/** Presentation twin: strip delimiters, no case change. */
+export declare function displayName(raw: string): string;
+export declare function foldTableName(parts: string[]): string[];
+export declare function matchesSourceKey(key: string, rawPart: string): boolean;

package/dist/redshift/fold.js

@@ -0,0 +1,31 @@
+// Redshift identifier folding. The FoldRule plus its bound engine, colocated here because BOTH the
+// upstream lower() and the downstream DialectBehavior need it (the fold rule is the one dialect concern
+// used at two stages). Redshift folds both unquoted and quoted identifiers to lowercase; double-quote
+// is the delimiter, doubled to escape.
+import { displayWith, foldWith } from "../ident/fold.js";
+const DOUBLE_QUOTE = ['"', '"'];
+// docs.aws.amazon.com/redshift/latest/dg/r_names.html — verified live: "ASCII letters in
+// standard and delimited identifiers are case-insensitive and are folded to lowercase in the
+// database" — explicitly covers BOTH unquoted and quoted by default (the
+// enable_case_sensitive_identifier parameter can flip quoted identifiers case-sensitive; this
+// module encodes the default). Doubled-quote escape: "To use a double quotation mark in a
+// string, you must precede it with another double quotation mark character."
+export const REDSHIFT_FOLD_RULE = {
+    delimiters: [DOUBLE_QUOTE],
+    unquoted: "lower",
+    quoted: "lower",
+};
+/** Fold an identifier to its Redshift identity key. */
+export function fold(raw, kind = "other") {
+    return foldWith(REDSHIFT_FOLD_RULE, raw, kind);
+}
+/** Presentation twin: strip delimiters, no case change. */
+export function displayName(raw) {
+    return displayWith(REDSHIFT_FOLD_RULE, raw);
+}
+export function foldTableName(parts) {
+    return parts.map((p) => fold(p, "table"));
+}
+export function matchesSourceKey(key, rawPart) {
+    return key === fold(rawPart) || key === fold(rawPart, "table");
+}

package/dist/redshift/index.d.ts

@@ -0,0 +1,7 @@
+import { lower } from "./lower.js";
+import { parseRedshift } from "./parse.js";
+export declare const redshift: {
+    parse: typeof parseRedshift;
+    lower: typeof lower;
+    behavior: import("../dialect-behavior/behavior.js").DialectBehavior;
+};

package/dist/redshift/index.js

@@ -0,0 +1,10 @@
+// The complete redshift dialect module: parse + lower (front end) and behavior (semantic knowledge).
+// The registry wires this; to understand everything sqllens does for redshift, read this folder.
+import { redshiftBehavior } from "./behavior.js";
+import { lower } from "./lower.js";
+import { parseRedshift } from "./parse.js";
+export const redshift = {
+    parse: parseRedshift,
+    lower,
+    behavior: redshiftBehavior,
+};

package/dist/{infer/redshift.d.ts → redshift/infer.d.ts}

@@ -1,5 +1,5 @@
-import { type Type } from "./types.js";
-import type { FnRule } from "./functions.js";
+import { type Type } from "../infer/types.js";
+import type { FnRule } from "../infer/functions.js";
 export declare const REDSHIFT_ALIASES: Record<string, string>;
 export declare function redshiftParseType(text: string): Type;
 /** Redshift literal forms. Numeric rules per the AWS SQL reference "Numeric literals"

package/dist/{infer/redshift.js → redshift/infer.js}

@@ -1,5 +1,6 @@
-import { parseType, scalar, UNKNOWN } from "./types.js";
-import { commonType, widenSum } from "./coerce.js";
+import { parseType, scalar, UNKNOWN } from "../infer/types.js";
+import { commonType, widenSum } from "../infer/coerce.js";
+import { fold } from "./fold.js";
 // ---------------------------------------------------------------------------
 // Redshift (Postgres-derived) inference knowledge. Scalar-name aliases map the
 // Postgres/Redshift type vocabulary onto the shared canonical names; division
@@ -36,7 +37,7 @@ export const REDSHIFT_ALIASES = {
     varbinary: "binary",
 };
 export function redshiftParseType(text) {
-    return parseType(text, REDSHIFT_ALIASES, "redshift");
+    return parseType(text, REDSHIFT_ALIASES, fold);
 }
 const BOOLEAN = scalar("boolean");
 /** Redshift literal forms. Numeric rules per the AWS SQL reference "Numeric literals"

package/dist/redshift/lower.js

@@ -3,7 +3,7 @@ import { RedshiftParser as P } from "../generated/redshift/RedshiftParser.js";
 import { keywordCategory, swallowedCategories, swallowedStatements } from "../ir/statement.js";
 import { partSpansOf } from "../ir/part-span.js";
 import { freezeIR } from "../ir/freeze.js";
-import { displayName } from "../ident/fold.js";
+import { displayName } from "./fold.js";
 // ---------------------------------------------------------------------------
 // Lowering — Amazon Redshift (bytebase/parser fork, a PostgreSQL-grammar fork)
 // CST -> the shared dialect-neutral IR (src/ir/ir.ts). The semantic layer runs
@@ -1321,7 +1321,7 @@ function lowerFuncExpr(node) {
     if (!app)
         return otherExpr(node);
     const fname = firstShallow(app, P.RULE_func_name);
-    const name = (fname ? displayName(lastName(fname), "redshift") : (leftmostToken(app) ?? "")).toLowerCase();
+    const name = (fname ? displayName(lastName(fname)) : (leftmostToken(app) ?? "")).toLowerCase();
     const args = funcArgs(app);
     // WITHIN GROUP (ORDER BY …) keys feed the aggregate — include as args.
     const within = directChildrenOfRule(node, P.RULE_within_group_clause)[0];

package/dist/redshift/signatures.generated.d.ts

@@ -0,0 +1,6 @@
+import type { FnSignature } from "../signature/signatures.js";
+/** The merged function-signature table for redshift: curated overrides folded over the harvested
+ *  doc-derived long tail (overrides win by key, replacing the whole overload set), keyed by
+ *  lowercased name. Each name maps to an ORDERED overload set - a name with one documented shape
+ *  is a one-element array. `origin` says which layer produced the set. */
+export declare const REDSHIFT_SIGNATURES: Record<string, FnSignature[]>;