@kuindji/typed-sql 0.2.0 → 0.4.0

package/src/validation/validate-columns.ts

@@ -1,12 +1,12 @@
 // Table/column existence + qualified/unqualified ref + scope-shape validation.
 import type { AliasesInQuery, InsertTargetTable, TableKeyValid, TablesInQuery, UpdateTargetTable } from "../tables.js";
 import type { AllTrue, And, StartsWith } from "../utils.js";
-import type { CleanIdent, DQuoteSpaceSentinel, ExceedsLengthBudget, ExtractAliasResult, ExtractBefore, ExtractConflictColumns, ExtractConflictUpdateExcludedCols, ExtractConflictUpdateSetColumns, ExtractInsertColumns, ExtractLastWhere, ExtractReturningList, ExtractSelectList, ExtractUpdateSetColumns, ReplaceAll, SplitSelectList, StripSubqueries, TokenizeLoose, Trim } from "../parsing.js";
-import type { ColumnRefValidLooseWith, IsSimpleRefPart, QualifiedColumnRefs, ResolveAlias, TableKeysByName, UnqualifiedColumnRefs, UnqualifiedColumnValid } from "../columns.js";
+import type { CleanIdent, DQuoteSpaceSentinel, ExceedsLengthBudget, ExtractAliasResult, ExtractBefore, ExtractConflictColumns, ExtractConflictUpdateExcludedCols, ExtractConflictUpdateSetColumns, ExtractInsertColumns, ExtractLastWhere, ExtractReturningList, ExtractSelectList, ExtractUpdateSetColumns, ReplaceAll, SplitSelectList, StripSubqueries, Trim } from "../parsing.js";
+import type { ColumnRefValidLooseWith, IsSimpleRefPart, QualifiedRefScan, ResolveAlias, TableKeysByName, UnqualifiedRefScan, UnqualifiedColumnValid } from "../columns.js";
 import type { ColumnsExistInTable, RefScanBeforeOrderBy, RefScanOrderBy, RefScanSegment, SelectAliasesInQuery, SelectAliasSet } from "./return-types.js";
-import type { CteRow, SingleCteMatch } from "./cte.js";
+import type { CteNames, CteRow, SingleCteMatch } from "./cte.js";
 import type { DatabaseSchema } from "../schema.js";
-import type { DerivedRenamedRow, DerivedTableMatch } from "./return-derived.js";
+import type { AliasHasNoSpace, DerivedRenamedRow, DerivedTableMatch } from "./return-derived.js";
 import type { ExprsValidList } from "../expressions.js";
 import type { HasReturning, QueryKind, ValidateSQLNormalized } from "./dispatch.js";
 
@@ -105,7 +105,7 @@ export type KeyInRow<K extends string, Row> = [K] extends [keyof Row] ? true : f
 
 // Validate every column-reference candidate in an arbitrary text segment (an
 // outer WHERE predicate, or a function call's argument list) against the
-// CTE/derived relation's exposed `Row`. Reuses the same token walkers the core
+// CTE/derived relation's exposed `Row`. Reuses the same ref-scan walkers the core
 // validator uses to surface refs, then checks each via `ProjRefInRow` (qualifier
 // must equal the relation `Name`, column must be a key of `Row`). `Tables`/
 // `Aliases` are `never`: the walkers only consult them to EXCLUDE table/alias
@@ -115,22 +115,20 @@ export type KeyInRow<K extends string, Row> = [K] extends [keyof Row] ? true : f
 export type SegRefsInRow<Seg extends string, Name extends string, Row, S extends DatabaseSchema> =
     Trim<Seg> extends ""
         ? true
-        : TokenizeLoose<Seg> extends infer Toks extends string[]
-            ? And<
-                AllTrue<
-                    QualifiedColumnRefs<Toks, S, never, never> extends infer R
-                        ? R extends string ? ProjRefInRow<R, Name, Row, S> : true
-                        : true
-                >,
-                AllTrue<
-                    UnqualifiedColumnRefs<Toks, S, never, never> extends infer R
-                        ? R extends string ? ProjRefInRow<R, Name, Row, S> : true
-                        : true
-                >,
-                true,
-                true
-              >
-            : true;
+        : And<
+            AllTrue<
+                QualifiedRefScan<Seg> extends infer R
+                    ? R extends string ? ProjRefInRow<R, Name, Row, S> : true
+                    : true
+            >,
+            AllTrue<
+                UnqualifiedRefScan<Seg, S, never, never> extends infer R
+                    ? R extends string ? ProjRefInRow<R, Name, Row, S> : true
+                    : true
+            >,
+            true,
+            true
+          >;
 
 // The outer query's WHERE predicate, scoped to the CTE/derived relation's exposed
 // row. Strip subquery bodies FIRST so the derived/CTE body's own WHERE is never
@@ -191,22 +189,20 @@ type ExtractOrderByExpr<S extends string> =
 export type SegRefsInRowWithAliases<Seg extends string, Name extends string, Row, S extends DatabaseSchema, SelAliases extends string> =
     Trim<Seg> extends ""
         ? true
-        : TokenizeLoose<Seg> extends infer Toks extends string[]
-            ? And<
-                AllTrue<
-                    QualifiedColumnRefs<Toks, S, never, never> extends infer R
-                        ? R extends string ? RefInRowOrAlias<R, Name, Row, S, SelAliases> : true
-                        : true
-                >,
-                AllTrue<
-                    UnqualifiedColumnRefs<Toks, S, never, never> extends infer R
-                        ? R extends string ? RefInRowOrAlias<R, Name, Row, S, SelAliases> : true
-                        : true
-                >,
-                true,
-                true
-              >
-            : true;
+        : And<
+            AllTrue<
+                QualifiedRefScan<Seg> extends infer R
+                    ? R extends string ? RefInRowOrAlias<R, Name, Row, S, SelAliases> : true
+                    : true
+            >,
+            AllTrue<
+                UnqualifiedRefScan<Seg, S, never, never> extends infer R
+                    ? R extends string ? RefInRowOrAlias<R, Name, Row, S, SelAliases> : true
+                    : true
+            >,
+            true,
+            true
+          >;
 
 export type RefInRowOrAlias<R extends string, Name extends string, Row, S extends DatabaseSchema, SelAliases extends string> =
     [SelAliases] extends [never]
@@ -231,9 +227,7 @@ export type AllTablesValidFor<Tables extends string, S extends DatabaseSchema> =
 export type AllColumnsValid<N extends string, S extends DatabaseSchema> =
     TablesInQuery<N, S> extends infer Tables extends string
         ? AliasesInQuery<N, S> extends infer Aliases extends string
-            ? TokenizeLoose<RefScanSegment<N>> extends infer LooseTokens extends string[]
-                ? AllColumnsValidFor<N, S, Tables, Aliases, LooseTokens>
-                : false
+            ? AllColumnsValidFor<N, S, Tables, Aliases, RefScanSegment<N>>
             : false
         : false;
 
@@ -242,7 +236,7 @@ export type AllColumnsValidFor<
     S extends DatabaseSchema,
     Tables extends string,
     Aliases extends string,
-    LooseTokens extends string[]
+    RefSeg extends string
 > = SelectAliasSet<N> extends infer SelectAliases extends string
     ? QueryKind<N> extends "update"
         // A normal (non-high-complexity) UPDATE has no subquery/CASE SET, so its
@@ -254,14 +248,14 @@ export type AllColumnsValidFor<
             ColumnsValidInUpdate<N, S>,
             ColumnsValidInInsert<N, S>,
             ColumnsValidInSelectOrReturningFor<N, S, Tables, Aliases>,
-            QualifiedColumnRefsValidFor<N, S, Tables, Aliases, LooseTokens>,
-            UnqualifiedColumnRefsValidFor<N, S, Tables, Aliases, LooseTokens, never>
+            QualifiedColumnRefsValidFor<N, S, Tables, Aliases, RefSeg>,
+            UnqualifiedColumnRefsValidFor<N, S, Tables, Aliases, RefSeg, never>
         >
         : And<
             ColumnsValidInSelectOrReturningFor<N, S, Tables, Aliases>,
             ColumnsValidInInsert<N, S>,
             ColumnsValidInUpdate<N, S>,
-            QualifiedColumnRefsValidFor<N, S, Tables, Aliases, LooseTokens>,
+            QualifiedColumnRefsValidFor<N, S, Tables, Aliases, RefSeg>,
             // A SELECT-list alias is only resolvable in ORDER BY — NOT in
             // WHERE/GROUP/HAVING. So the unqualified ref-scan blesses the alias
             // set ONLY for the ORDER BY token slice; the FROM..(pre-order-by)
@@ -284,10 +278,10 @@ export type SelectUnqualifiedRefsScoped<
     SelectAliases extends string
 > =
     [SelectAliases] extends [never]
-        ? UnqualifiedColumnRefsValidFor<N, S, Tables, Aliases, TokenizeLoose<RefScanSegment<N>>, never>
+        ? UnqualifiedColumnRefsValidFor<N, S, Tables, Aliases, RefScanSegment<N>, never>
         : And<
-            UnqualifiedColumnRefsValidFor<N, S, Tables, Aliases, TokenizeLoose<RefScanBeforeOrderBy<N>>, never>,
-            UnqualifiedColumnRefsValidFor<N, S, Tables, Aliases, TokenizeLoose<RefScanOrderBy<N>>, SelectAliases>,
+            UnqualifiedColumnRefsValidFor<N, S, Tables, Aliases, RefScanBeforeOrderBy<N>, never>,
+            UnqualifiedColumnRefsValidFor<N, S, Tables, Aliases, RefScanOrderBy<N>, SelectAliases>,
             true,
             true,
             true
@@ -309,7 +303,7 @@ export type ColumnsValidInSelectOrReturningFor<
     HasReturning<N> extends true
         ? [Tables] extends [never]
             ? true
-            : ExprsValidList<SplitSelectList<ReplaceAll<ExtractReturningList<N>, DQuoteSpaceSentinel, " ">>, Tables, Aliases, S>
+            : ExprsValidList<SplitSelectList<ReplaceAll<ExtractReturningList<N>, DQuoteSpaceSentinel, " ">>, Tables, Aliases, S, [], SelectLocalRels<N>>
         : QueryKind<N> extends "select"
             ? [Tables] extends [never]
                 ? true
@@ -318,9 +312,18 @@ export type ColumnsValidInSelectOrReturningFor<
                 // The alias set restores those spaces, so restore them here too or a
                 // qualifier through a space-bearing quoted alias (`"user alias".id`)
                 // would never match its registered alias (round-12 regression).
-                : ExprsValidList<SplitSelectList<ReplaceAll<ExtractSelectList<N>, DQuoteSpaceSentinel, " ">>, Tables, Aliases, S>
+                : ExprsValidList<SplitSelectList<ReplaceAll<ExtractSelectList<N>, DQuoteSpaceSentinel, " ">>, Tables, Aliases, S, [], SelectLocalRels<N>>
             : true;
 
+// Query-local relation names whose qualified refs the projection-list validator
+// must bless: a `WITH`-query's CTE names. (A CTE that reaches the core validator
+// — e.g. `WITH ... SELECT ... JOIN ...` — is collected into `TablesInQuery` as a
+// bogus base table for the ref-resolution, so `cte.col` in the SELECT list would
+// otherwise resolve `never` and falsely reject.) Gated on the `with ` prefix so
+// CTE-free queries pay nothing.
+type SelectLocalRels<N extends string> =
+    N extends `with ${string}` ? CteNames<N> : never;
+
 // insert
 
 export type ColumnsValidInInsert<N extends string, S extends DatabaseSchema> =
@@ -356,9 +359,7 @@ export type ColumnsValidInUpdate<N extends string, S extends DatabaseSchema> =
 export type QualifiedColumnRefsValid<N extends string, S extends DatabaseSchema> =
     TablesInQuery<N, S> extends infer Tables extends string
         ? AliasesInQuery<N, S> extends infer Aliases extends string
-            ? TokenizeLoose<RefScanSegment<N>> extends infer LooseTokens extends string[]
-                ? QualifiedColumnRefsValidFor<N, S, Tables, Aliases, LooseTokens>
-                : true
+            ? QualifiedColumnRefsValidFor<N, S, Tables, Aliases, RefScanSegment<N>>
             : true
         : true;
 
@@ -367,11 +368,67 @@ export type QualifiedColumnRefsValidFor<
     S extends DatabaseSchema,
     Tables extends string,
     Aliases extends string,
-    LooseTokens extends string[]
-> = QualifiedColumnRefs<LooseTokens, S, Tables, Aliases> extends infer Cols
-    ? AllTrue<Cols extends string ? ColumnRefValidLooseWith<Cols, Tables, Aliases, S> : true>
+    RefSeg extends string
+> =
+    // Common path: with no CTE and no parenthesised FROM source there is no local
+    // relation that could qualify a ref, so skip the (per-ref) local-relation
+    // blessing entirely — exact prior behavior, zero added cost.
+    HasLocalRelations<N> extends true
+        ? QualifiedRefsValidWithLocal<N, S, Tables, Aliases, RefSeg, CteNames<N>>
+        : QualifiedRefScan<RefSeg> extends infer Cols
+            ? AllTrue<Cols extends string ? ColumnRefValidLooseWith<Cols, Tables, Aliases, S> : true>
+            : true;
+
+// A "local relation" is a query-local name that is NOT a base table: a CTE name, or
+// the alias bound to a derived / VALUES / subquery FROM source (`from (…) [as]
+// x[(cols)]`). Its columns are not modeled in the schema, so a ref qualified by it
+// must be accepted leniently rather than resolved against a (non-existent) base
+// table. Blessing only ever turns a reject into an accept — never the reverse —
+// consistent with the lenient-parser contract.
+type HasLocalRelations<N extends string> =
+    N extends `with ${string}` ? true :
+    N extends `${string} from (${string}` ? true :
+    N extends `${string} join (${string}` ? true :
+    false;
+
+type QualifiedRefsValidWithLocal<
+    N extends string,
+    S extends DatabaseSchema,
+    Tables extends string,
+    Aliases extends string,
+    RefSeg extends string,
+    Ctes extends string
+> = QualifiedRefScan<RefSeg> extends infer Cols
+    ? AllTrue<
+        Cols extends string
+            ? IsLocalRelation<RefQualifierOf<Cols>, Ctes, N> extends true
+                ? true
+                : ColumnRefValidLooseWith<Cols, Tables, Aliases, S>
+            : true
+      >
     : true;
 
+// The qualifier (text before the first `.`) of a qualified column ref.
+type RefQualifierOf<Col extends string> =
+    Col extends `${infer Q}.${string}` ? CleanIdent<Q> : never;
+
+type IsLocalRelation<Q extends string, Ctes extends string, N extends string> =
+    [Q] extends [never] ? false :
+    Q extends Ctes ? true :
+    IsDerivedSourceAlias<Q, N>;
+
+// Detect `… ) [as] q …` / `… ) [as] q( …` — q is the alias bound to a parenthesised
+// (derived / VALUES / subquery) FROM source. N is already normalized (lowercase
+// outside quotes); q is the cleaned, lowercased qualifier.
+type IsDerivedSourceAlias<Q extends string, N extends string> =
+    N extends `${string}) as ${Q} ${string}` ? true :
+    N extends `${string}) as ${Q}(${string}` ? true :
+    N extends `${string}) as ${Q}` ? true :
+    N extends `${string}) ${Q} ${string}` ? true :
+    N extends `${string}) ${Q}(${string}` ? true :
+    N extends `${string}) ${Q}` ? true :
+    false;
+
 // Once a table is given a range alias (`FROM products p`), PostgreSQL hides the
 // original table name as a correlation name for that query level — `products.id`
 // is then invalid; only `p.id` works. The lenient qualified-ref check accepts
@@ -403,12 +460,12 @@ export type NoAliasShadowedQualifiers<
     [AliasedTableKeys<Aliases>] extends [never]
         ? true
         // A shadowable qualifier is a `qualifier.column` token, which requires a
-        // `.`. With no `.` anywhere, `QualifiedColumnRefs` accumulates `never` and
-        // `AllTrue<never>` is `true` — so skip the whole-query `TokenizeLoose<N>`
-        // re-walk (computed nowhere else) on dot-free queries. Exact-equivalent.
+        // `.`. With no `.` anywhere, `QualifiedRefScan` accumulates `never` and
+        // `AllTrue<never>` is `true` — so skip the whole-query re-scan (computed
+        // nowhere else) on dot-free queries. Exact-equivalent.
         : N extends `${string}.${string}`
             ? AllTrue<
-                QualifiedColumnRefs<TokenizeLoose<N>, S, Tables, Aliases> extends infer R
+                QualifiedRefScan<N> extends infer R
                     ? R extends `${infer Q}.${string}`
                         ? QualifierShadowedByAlias<Q, Tables, Aliases, S> extends true
                             ? false
@@ -456,7 +513,7 @@ export type OuterScopeUnqualifiedValid<N extends string, S extends DatabaseSchem
                                         S,
                                         OT,
                                         OA,
-                                        TokenizeLoose<RefScanSegment<Stripped>>,
+                                        RefScanSegment<Stripped>,
                                         SelectAliasesInQuery<Stripped>
                                       >
                                     : true
@@ -469,10 +526,8 @@ export type OuterScopeUnqualifiedValid<N extends string, S extends DatabaseSchem
 export type UnqualifiedColumnRefsValid<N extends string, S extends DatabaseSchema> =
     TablesInQuery<N, S> extends infer Tables extends string
         ? AliasesInQuery<N, S> extends infer Aliases extends string
-            ? TokenizeLoose<RefScanSegment<N>> extends infer LooseTokens extends string[]
-                ? SelectAliasesInQuery<N> extends infer SelectAliases extends string
-                    ? UnqualifiedColumnRefsValidFor<N, S, Tables, Aliases, LooseTokens, SelectAliases>
-                    : true
+            ? SelectAliasesInQuery<N> extends infer SelectAliases extends string
+                ? UnqualifiedColumnRefsValidFor<N, S, Tables, Aliases, RefScanSegment<N>, SelectAliases>
                 : true
             : true
         : true;
@@ -482,14 +537,53 @@ export type UnqualifiedColumnRefsValidFor<
     S extends DatabaseSchema,
     Tables extends string,
     Aliases extends string,
-    LooseTokens extends string[],
+    RefSeg extends string,
     SelectAliases extends string
-> = UnqualifiedColumnRefs<LooseTokens, S, Tables, Aliases> extends infer Cols
+> = UnqualifiedRefScan<RefSeg, S, Tables, Aliases> extends infer Cols
     ? AllTrue<
         Cols extends string
             ? CleanIdent<Cols> extends SelectAliases
                 ? true
-                : UnqualifiedColumnValid<Cols, Tables, Aliases, S>
+                : UnqualifiedColumnValid<Cols, Tables, Aliases, S> extends true
+                    ? true
+                    // A derived/VALUES source's column-alias list (`... ) as
+                    // src(id, t)`) survives tokenization as bare identifier tokens,
+                    // and `t` is not a schema column anywhere — bless names that
+                    // belong to such a list. Checked ONLY after normal resolution
+                    // fails, so valid queries never pay for the extraction, and
+                    // blessing can only turn a reject into an accept (lenient
+                    // contract).
+                    : CleanIdent<Cols> extends SourceAliasListCols<N>
+                        ? true
+                        : false
             : true
     >
     : true;
+
+// Every column name bound by a derived-source column-alias list — `) as p(a, b)`
+// / `) p(a, b)` — plus CTE column-alias lists (`with c(x, y) as (`). Collected
+// across ALL occurrences in the (normalized, single-line) query. The alias word
+// itself must be space-free, mirroring `DerivedColsAfterAlias`'s guard, so a
+// trailing `WHERE ... IN (...)` paren group is not misread as a column list.
+type SourceAliasListCols<N extends string> =
+    N extends `with ${infer CteHead}(${infer CteCols}) as (${infer Rest}`
+        ? AliasHasNoSpace<Trim<CteHead>> extends true
+            ? ColNamesFromList<CteCols> | DerivedAliasListCols<Rest>
+            : DerivedAliasListCols<N>
+        : DerivedAliasListCols<N>;
+
+type DerivedAliasListCols<N extends string, Steps extends any[] = []> =
+    Steps["length"] extends 15
+        ? never
+        : N extends `${string}) as ${infer Rest}`
+            ? Rest extends `${infer Alias}(${infer Cols})${infer Tail}`
+                ? AliasHasNoSpace<Trim<Alias>> extends true
+                    ? ColNamesFromList<Cols> | DerivedAliasListCols<Tail, [any, ...Steps]>
+                    : DerivedAliasListCols<Tail, [any, ...Steps]>
+                : never
+            : never;
+
+type ColNamesFromList<L extends string> =
+    L extends `${infer A},${infer R}`
+        ? CleanIdent<A> | ColNamesFromList<R>
+        : CleanIdent<L>;