sqllens 1.0.0 → 1.2.0

package/dist/postgres/fold.d.ts

@@ -0,0 +1,8 @@
+import { type FoldRule, type IdentKind } from "../ident/fold.js";
+export declare const POSTGRES_FOLD_RULE: FoldRule;
+/** Fold an identifier to its PostgreSQL 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/postgres/fold.js

@@ -0,0 +1,30 @@
+// PostgreSQL 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).
+//
+// postgresql.org/docs/18/sql-syntax-lexical.html §4.1.1 — verified live: "unquoted names are
+// always folded to lower case"; "Quoting an identifier also makes it case-sensitive" — example
+// "the identifiers FOO, foo, and "foo" are considered the same by PostgreSQL, but "Foo" and
+// "FOO" are different." Doubled-quote escape: "To include a double quote, write two double
+// quotes."
+import { displayWith, foldWith } from "../ident/fold.js";
+const DOUBLE_QUOTE = ['"', '"'];
+export const POSTGRES_FOLD_RULE = {
+    delimiters: [DOUBLE_QUOTE],
+    unquoted: "lower",
+    quoted: "preserve",
+};
+/** Fold an identifier to its PostgreSQL identity key. */
+export function fold(raw, kind = "other") {
+    return foldWith(POSTGRES_FOLD_RULE, raw, kind);
+}
+/** Presentation twin: strip delimiters, no case change. */
+export function displayName(raw) {
+    return displayWith(POSTGRES_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/postgres/index.d.ts

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

package/dist/postgres/index.js

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

package/dist/{infer/postgres.d.ts → postgres/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 POSTGRES_ALIASES: Record<string, string>;
 export declare function postgresParseType(text: string): Type;
 /** PostgreSQL literal forms — syntax-lexical §4.1.2: a numeric constant with neither decimal point

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

@@ -1,5 +1,6 @@
-import { parseType, scalar, UNKNOWN } from "./types.js";
-import { commonType } from "./coerce.js";
+import { parseType, scalar, UNKNOWN } from "../infer/types.js";
+import { commonType } from "../infer/coerce.js";
+import { fold } from "./fold.js";
 // ---------------------------------------------------------------------------
 // PostgreSQL inference knowledge. Scalar-name aliases map the Postgres type
 // vocabulary onto the shared canonical names; integer division truncates
@@ -44,7 +45,7 @@ export const POSTGRES_ALIASES = {
     "bit varying": "bit",
 };
 export function postgresParseType(text) {
-    return parseType(text, POSTGRES_ALIASES, "postgres");
+    return parseType(text, POSTGRES_ALIASES, fold);
 }
 const S = scalar("string");
 const I = scalar("int");

package/dist/postgres/lower.js

@@ -3,7 +3,7 @@ import { PostgresParser as P } from "../generated/postgres/PostgresParser.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 — PostgreSQL (bytebase/parser postgresql/ fork, TVL-lineage grammar)
 // CST -> the shared dialect-neutral IR (src/ir/ir.ts). The semantic layer runs
@@ -1191,7 +1191,7 @@ function lowerFuncExpr(node) {
     if (!app)
         return otherExpr(node);
     const fname = firstShallow(app, P.RULE_func_name);
-    const name = (fname ? displayName(lastName(fname), "postgres") : (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/postgres/signatures.generated.d.ts

@@ -0,0 +1,6 @@
+import type { FnSignature } from "../signature/signatures.js";
+/** The merged function-signature table for postgres: 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 POSTGRES_SIGNATURES: Record<string, FnSignature[]>;