npm - @kuindji/typed-sql - Versions diffs - 0.1.0 - Mend

@kuindji/typed-sql 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (208) hide show

package/LICENSE +21 -0
package/README.md +227 -0
package/dist/builder/assemble.d.ts +13 -0
package/dist/builder/assemble.d.ts.map +1 -0
package/dist/builder/assemble.js +86 -0
package/dist/builder/assemble.js.map +1 -0
package/dist/builder/condition-tree.d.ts +27 -0
package/dist/builder/condition-tree.d.ts.map +1 -0
package/dist/builder/condition-tree.js +91 -0
package/dist/builder/condition-tree.js.map +1 -0
package/dist/builder/conditional-sql.d.ts +80 -0
package/dist/builder/conditional-sql.d.ts.map +1 -0
package/dist/builder/conditional-sql.js +88 -0
package/dist/builder/conditional-sql.js.map +1 -0
package/dist/builder/db.d.ts +76 -0
package/dist/builder/db.d.ts.map +1 -0
package/dist/builder/db.js +12 -0
package/dist/builder/db.js.map +1 -0
package/dist/builder/delete.d.ts +39 -0
package/dist/builder/delete.d.ts.map +1 -0
package/dist/builder/delete.js +33 -0
package/dist/builder/delete.js.map +1 -0
package/dist/builder/extract-params.d.ts +97 -0
package/dist/builder/extract-params.d.ts.map +1 -0
package/dist/builder/extract-params.js +2 -0
package/dist/builder/extract-params.js.map +1 -0
package/dist/builder/index.d.ts +23 -0
package/dist/builder/index.d.ts.map +1 -0
package/dist/builder/index.js +14 -0
package/dist/builder/index.js.map +1 -0
package/dist/builder/insert.d.ts +51 -0
package/dist/builder/insert.d.ts.map +1 -0
package/dist/builder/insert.js +39 -0
package/dist/builder/insert.js.map +1 -0
package/dist/builder/mutate.d.ts +28 -0
package/dist/builder/mutate.d.ts.map +1 -0
package/dist/builder/mutate.js +17 -0
package/dist/builder/mutate.js.map +1 -0
package/dist/builder/params.d.ts +22 -0
package/dist/builder/params.d.ts.map +1 -0
package/dist/builder/params.js +65 -0
package/dist/builder/params.js.map +1 -0
package/dist/builder/return-type.d.ts +39 -0
package/dist/builder/return-type.d.ts.map +1 -0
package/dist/builder/return-type.js +2 -0
package/dist/builder/return-type.js.map +1 -0
package/dist/builder/scanner.d.ts +49 -0
package/dist/builder/scanner.d.ts.map +1 -0
package/dist/builder/scanner.js +240 -0
package/dist/builder/scanner.js.map +1 -0
package/dist/builder/select.d.ts +76 -0
package/dist/builder/select.d.ts.map +1 -0
package/dist/builder/select.js +240 -0
package/dist/builder/select.js.map +1 -0
package/dist/builder/sql-tag.d.ts +319 -0
package/dist/builder/sql-tag.d.ts.map +1 -0
package/dist/builder/sql-tag.js +3 -0
package/dist/builder/sql-tag.js.map +1 -0
package/dist/builder/sql.d.ts +17 -0
package/dist/builder/sql.d.ts.map +1 -0
package/dist/builder/sql.js +36 -0
package/dist/builder/sql.js.map +1 -0
package/dist/builder/state.d.ts +53 -0
package/dist/builder/state.d.ts.map +1 -0
package/dist/builder/state.js +18 -0
package/dist/builder/state.js.map +1 -0
package/dist/builder/update.d.ts +60 -0
package/dist/builder/update.d.ts.map +1 -0
package/dist/builder/update.js +40 -0
package/dist/builder/update.js.map +1 -0
package/dist/builder/write-assemble.d.ts +5 -0
package/dist/builder/write-assemble.d.ts.map +1 -0
package/dist/builder/write-assemble.js +57 -0
package/dist/builder/write-assemble.js.map +1 -0
package/dist/builder/write-state.d.ts +39 -0
package/dist/builder/write-state.d.ts.map +1 -0
package/dist/builder/write-state.js +6 -0
package/dist/builder/write-state.js.map +1 -0
package/dist/builder/write-tag.d.ts +91 -0
package/dist/builder/write-tag.d.ts.map +1 -0
package/dist/builder/write-tag.js +2 -0
package/dist/builder/write-tag.js.map +1 -0
package/dist/columns.d.ts +33 -0
package/dist/columns.d.ts.map +1 -0
package/dist/columns.js +2 -0
package/dist/columns.js.map +1 -0
package/dist/expressions.d.ts +71 -0
package/dist/expressions.d.ts.map +1 -0
package/dist/expressions.js +2 -0
package/dist/expressions.js.map +1 -0
package/dist/index.d.ts +22 -0
package/dist/index.d.ts.map +1 -0
package/dist/index.js +5 -0
package/dist/index.js.map +1 -0
package/dist/parsing/extract.d.ts +47 -0
package/dist/parsing/extract.d.ts.map +1 -0
package/dist/parsing/extract.js +2 -0
package/dist/parsing/extract.js.map +1 -0
package/dist/parsing/normalize.d.ts +44 -0
package/dist/parsing/normalize.d.ts.map +1 -0
package/dist/parsing/normalize.js +2 -0
package/dist/parsing/normalize.js.map +1 -0
package/dist/parsing/pg-literals.d.ts +37 -0
package/dist/parsing/pg-literals.d.ts.map +1 -0
package/dist/parsing/pg-literals.js +2 -0
package/dist/parsing/pg-literals.js.map +1 -0
package/dist/parsing/split.d.ts +100 -0
package/dist/parsing/split.d.ts.map +1 -0
package/dist/parsing/split.js +2 -0
package/dist/parsing/split.js.map +1 -0
package/dist/parsing/string-utils.d.ts +29 -0
package/dist/parsing/string-utils.d.ts.map +1 -0
package/dist/parsing/string-utils.js +2 -0
package/dist/parsing/string-utils.js.map +1 -0
package/dist/parsing/tokenize.d.ts +27 -0
package/dist/parsing/tokenize.d.ts.map +1 -0
package/dist/parsing/tokenize.js +2 -0
package/dist/parsing/tokenize.js.map +1 -0
package/dist/parsing.d.ts +7 -0
package/dist/parsing.d.ts.map +1 -0
package/dist/parsing.js +9 -0
package/dist/parsing.js.map +1 -0
package/dist/partial.d.ts +30 -0
package/dist/partial.d.ts.map +1 -0
package/dist/partial.js +10 -0
package/dist/partial.js.map +1 -0
package/dist/schema.d.ts +28 -0
package/dist/schema.d.ts.map +1 -0
package/dist/schema.js +2 -0
package/dist/schema.js.map +1 -0
package/dist/tables.d.ts +34 -0
package/dist/tables.d.ts.map +1 -0
package/dist/tables.js +2 -0
package/dist/tables.js.map +1 -0
package/dist/utils.d.ts +13 -0
package/dist/utils.d.ts.map +1 -0
package/dist/utils.js +3 -0
package/dist/utils.js.map +1 -0
package/dist/validation/cte.d.ts +54 -0
package/dist/validation/cte.d.ts.map +1 -0
package/dist/validation/cte.js +2 -0
package/dist/validation/cte.js.map +1 -0
package/dist/validation/dispatch.d.ts +31 -0
package/dist/validation/dispatch.d.ts.map +1 -0
package/dist/validation/dispatch.js +2 -0
package/dist/validation/dispatch.js.map +1 -0
package/dist/validation/joins.d.ts +16 -0
package/dist/validation/joins.d.ts.map +1 -0
package/dist/validation/joins.js +2 -0
package/dist/validation/joins.js.map +1 -0
package/dist/validation/return-derived.d.ts +67 -0
package/dist/validation/return-derived.d.ts.map +1 -0
package/dist/validation/return-derived.js +5 -0
package/dist/validation/return-derived.js.map +1 -0
package/dist/validation/return-types.d.ts +41 -0
package/dist/validation/return-types.d.ts.map +1 -0
package/dist/validation/return-types.js +2 -0
package/dist/validation/return-types.js.map +1 -0
package/dist/validation/validate-columns.d.ts +63 -0
package/dist/validation/validate-columns.d.ts.map +1 -0
package/dist/validation/validate-columns.js +2 -0
package/dist/validation/validate-columns.js.map +1 -0
package/dist/validation.d.ts +7 -0
package/dist/validation.d.ts.map +1 -0
package/dist/validation.js +9 -0
package/dist/validation.js.map +1 -0
package/package.json +64 -0
package/src/builder/assemble.ts +100 -0
package/src/builder/condition-tree.ts +162 -0
package/src/builder/conditional-sql.ts +325 -0
package/src/builder/db.ts +281 -0
package/src/builder/delete.ts +57 -0
package/src/builder/extract-params.ts +507 -0
package/src/builder/index.ts +58 -0
package/src/builder/insert.ts +75 -0
package/src/builder/mutate.ts +55 -0
package/src/builder/params.ts +95 -0
package/src/builder/return-type.ts +66 -0
package/src/builder/scanner.ts +254 -0
package/src/builder/select.ts +470 -0
package/src/builder/sql-tag.ts +422 -0
package/src/builder/sql.ts +51 -0
package/src/builder/state.ts +55 -0
package/src/builder/update.ts +77 -0
package/src/builder/write-assemble.ts +52 -0
package/src/builder/write-state.ts +43 -0
package/src/builder/write-tag.ts +119 -0
package/src/columns.ts +336 -0
package/src/expressions.ts +745 -0
package/src/index.ts +81 -0
package/src/parsing/extract.ts +260 -0
package/src/parsing/normalize.ts +243 -0
package/src/parsing/pg-literals.ts +289 -0
package/src/parsing/split.ts +288 -0
package/src/parsing/string-utils.ts +172 -0
package/src/parsing/tokenize.ts +321 -0
package/src/parsing.ts +8 -0
package/src/partial.ts +241 -0
package/src/schema.ts +130 -0
package/src/tables.ts +278 -0
package/src/utils.ts +43 -0
package/src/validation/cte.ts +198 -0
package/src/validation/dispatch.ts +312 -0
package/src/validation/joins.ts +198 -0
package/src/validation/return-derived.ts +253 -0
package/src/validation/return-types.ts +271 -0
package/src/validation/validate-columns.ts +489 -0
package/src/validation.ts +8 -0

package/src/utils.ts ADDED Viewed

@@ -0,0 +1,43 @@
+// Shared boolean and type utilities.
+export type And<
+    A extends boolean,
+    B extends boolean,
+    C extends boolean,
+    D extends boolean,
+    E extends boolean = true
+> = A extends true
+    ? (B extends true
+        ? (C extends true
+            ? (D extends true
+                ? (E extends true ? true : false)
+                : false)
+            : false)
+        : false)
+    : false;
+export type AllTrue<U> = Exclude<U, true> extends never ? true : false;
+export type AnyTrue<U> = Extract<U, true> extends never ? false : true;
+export type IsNever<T> = [T] extends [never] ? true : false;
+// True when `T` is a union of two or more members. A single member (or `never`)
+// is not a union. Used to test that a JOIN ... USING column exists on more than
+// one of the query's tables (it must hold on both sides of the join).
+export type IsUnion<T, U = T> =
+    [T] extends [never]
+        ? false
+        : T extends any
+            ? [U] extends [T]
+                ? false
+                : true
+            : false;
+export type StartsWith<S extends string, Prefix extends string> =
+    string extends S ? false : S extends `${Prefix}${string}` ? true : false;
+export type UnionToIntersection<U> =
+    (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+export type Simplify<T> = { [K in keyof T]: T[K] } & {};

package/src/validation/cte.ts ADDED Viewed

@@ -0,0 +1,198 @@
+// CTE name collection, CTE/WITH-DML result inference.
+import type { BuildDerivedReturn, DerivedSubRow } from "./return-derived.js";
+import type { CleanIdent, ExtractAliasResult, ExtractFromClause, ExtractSelectList, ReplaceWhitespace, SplitBalancedParen, SplitCommaSimple, SplitSelectList, Trim } from "../parsing.js";
+import type { DatabaseSchema } from "../schema.js";
+import type { QueryKind } from "./dispatch.js";
+import type { Simplify, UnionToIntersection } from "../utils.js";
+import type { TableKeyFromToken } from "../tables.js";
+// outer projection, output aliases and the `t(a,b)` column-alias list. We parse
+// the CTE deterministically and resolve the outer projection against the CTE's
+// row — treating the CTE name like a derived-table alias. Multi-CTE queries
+// (outer doesn't immediately follow the first balanced group) and CTE+join
+// outers fall back to the old behavior rather than risk a wrong shape.
+export type StripRecursiveKw<N extends string> =
+    N extends `with recursive ${infer R}` ? `with ${R}` : N;
+export type SingleCteMatch<N extends string> =
+    StripRecursiveKw<N> extends `with ${infer AfterWith}`
+        ? AfterWith extends `${infer Head} as ${infer Tail}`
+            ? Trim<Tail> extends `(${string}`
+                ? SplitBalancedParen<Trim<Tail>> extends { inner: infer Body extends string; rest: infer Rest extends string }
+                    ? Trim<Rest> extends `select ${string}`
+                        ? Trim<Rest> extends `${string} join ${string}`
+                            ? never
+                            : Trim<Body> extends `select ${string}`
+                                ? {
+                                    body: Trim<Body>;
+                                    outer: Trim<Rest>;
+                                    name: CteName<Trim<Head>>;
+                                    cols: CteCols<Trim<Head>>;
+                                  }
+                                : never
+                        : never
+                    : never
+                : never
+            : never
+        : never;
+export type CteName<Head extends string> =
+    Head extends `${infer Name}(${string}` ? CleanIdent<Trim<Name>> : CleanIdent<Head>;
+// Names declared by a leading `WITH [RECURSIVE] a AS (...), b AS (...) ...`
+// clause. These are query-local relation names, not base tables, so the
+// table-existence check must not reject them. Body parens are skipped via
+// `SplitBalancedParen` so an inner ` as ` (a column alias) is never mistaken for
+// a CTE boundary. Non-WITH queries resolve to `never` (a no-op exclude).
+export type CteNames<N extends string> =
+    StripRecursiveKw<N> extends `with ${infer AfterWith}`
+        ? CollectCteNames<Trim<AfterWith>>
+        : never;
+export type CollectCteNames<S extends string, Acc extends string = never> =
+    S extends `${infer Head} as ${infer Tail}`
+        ? Trim<Tail> extends `(${string}`
+            ? SplitBalancedParen<Trim<Tail>> extends { rest: infer Rest extends string }
+                ? Trim<Rest> extends `, ${infer More}`
+                    ? CollectCteNames<Trim<More>, Acc | CteName<Trim<Head>>>
+                    : Acc | CteName<Trim<Head>>
+                : Acc | CteName<Trim<Head>>
+            : Acc
+        : Acc;
+// The OUTER query of a `WITH a AS (...), b AS (...) <outer>` statement: the tail
+// that follows the last comma-separated CTE definition. Mirrors `CollectCteNames`'
+// balanced-paren walk over the CTE list, but instead of collecting names it
+// returns whatever remains after the final CTE body — i.e. the top-level
+// `SELECT ... FROM ...`. Used by the multi-CTE result path so the OUTER projection
+// is inferred, not the first inner CTE's select list (which a naive
+// `${_}select ${After}` match would grab). Falls back to `N` when the query isn't
+// a `WITH`, and to `""` when the CTE list can't be parsed.
+// `ReplaceWhitespace` (in `NormalizeQuery`) is step-capped, so on a long multi-CTE
+// query the OUTER select — which sits past the cap, at the very end — can keep its
+// raw `\n`/`\t`. `ExtractSelectList` matches `select ` with a literal space, so we
+// re-collapse whitespace on the (short) extracted outer before handing it on.
+export type CteOuterQuery<N extends string> =
+    StripRecursiveKw<N> extends `with ${infer AfterWith}`
+        ? ReplaceWhitespace<CollectCteOuter<Trim<AfterWith>>>
+        : N;
+export type CollectCteOuter<S extends string> =
+    S extends `${infer _Head} as ${infer Tail}`
+        ? Trim<Tail> extends `(${string}`
+            ? SplitBalancedParen<Trim<Tail>> extends { rest: infer Rest extends string }
+                ? Trim<Rest> extends `, ${infer More}`
+                    ? CollectCteOuter<Trim<More>>
+                    : Trim<Rest>
+                : ""
+            : ""
+        : "";
+// The first FROM relation token (alias-less) of a stripped outer query. Used as
+// the derived-table qualifier when resolving a multi-CTE outer projection.
+export type CteOuterFromName<Outer extends string> =
+    Trim<ExtractFromClause<Outer>> extends `${infer Rel} ${string}`
+        ? CleanIdent<Rel>
+        : CleanIdent<Trim<ExtractFromClause<Outer>>>;
+// Result row for a multi-CTE `SELECT` whose OUTER query reads from a single CTE
+// (no join into base tables). The CTE's columns aren't modeled as a schema
+// relation, so resolving the outer projection with the normal `ExprType` path
+// would fail every ref to `never` (and poison casts over them). Instead we treat
+// the CTE like a derived table and reuse `BuildDerivedReturn`/`DerivedProjType`:
+// a `expr::cast` projection recovers its type from the OUTER cast (`OuterCastTs`),
+// and any other ref falls back to `unknown` (conservative default — we don't
+// model the CTE row). The empty sub-row means bare CTE-column projections are
+// `unknown` rather than their true type; casts (the common rollup shape, e.g.
+// `avg(x)::int`) are typed precisely.
+export type MultiCteReturn<Outer extends string> =
+    BuildDerivedReturn<SplitSelectList<ExtractSelectList<Outer>>, CteOuterFromName<Outer>, {}>;
+// The normalized table keys for every declared CTE name, so they can be
+// `Exclude`d from the collected FROM tables before the existence check.
+export type CteTableKeys<N extends string, S extends DatabaseSchema> =
+    [CteNames<N>] extends [never] ? never : TableKeyFromToken<CteNames<N>, S>;
+// FROM/JOIN tables with the query-local CTE relation names removed.
+export type NonCteTables<N extends string, S extends DatabaseSchema, Tables extends string> =
+    Exclude<Tables, CteTableKeys<N, S>>;
+// A `WITH <cte> AS (...) <UPDATE|INSERT|DELETE> ...` statement: the inner
+// data-modifying statement after a SINGLE leading CTE. Result inference for these
+// must follow the top-level DML's RETURNING list, not the CTE body's projection.
+// Multi-CTE chains fall back to `never` (handled by the existing select path).
+export type WithDmlOuter<N extends string> =
+    StripRecursiveKw<N> extends `with ${infer AfterWith}`
+        ? AfterWith extends `${infer _Head} as ${infer Tail}`
+            ? Trim<Tail> extends `(${string}`
+                ? SplitBalancedParen<Trim<Tail>> extends { rest: infer Rest extends string }
+                    ? Trim<Rest> extends infer R extends string
+                        ? QueryKind<R> extends "update" | "insert" | "delete"
+                            ? R
+                            : never
+                        : never
+                    : never
+                : never
+            : never
+        : never;
+export type CteCols<Head extends string> =
+    Head extends `${string}(${infer Cols})${string}`
+        ? FilterCteCols<SplitCommaSimple<Cols>>
+        : [];
+export type FilterCteCols<Cols extends string[], Acc extends string[] = []> =
+    Cols extends [infer C extends string, ...infer Rest extends string[]]
+        ? CleanIdent<C> extends ""
+            ? FilterCteCols<Rest, Acc>
+            : FilterCteCols<Rest, [...Acc, CleanIdent<C>]>
+        : Acc;
+export type CteReturn<N extends string, S extends DatabaseSchema> =
+    SingleCteMatch<N> extends {
+        body: infer Body extends string;
+        outer: infer Outer extends string;
+        name: infer Name extends string;
+        cols: infer Cols extends string[];
+    }
+        ? CteRow<Body, Cols, S> extends infer Row
+            ? BuildDerivedReturn<SplitSelectList<ExtractSelectList<Outer>>, Name, Row>
+            : {}
+        : {};
+// The CTE's projected row. Without a column-alias list it's just the body's
+// projection; with `t(a, b)` the body columns are positionally renamed.
+export type CteRow<Body extends string, Cols extends string[], S extends DatabaseSchema> =
+    DerivedSubRow<Body, S> extends infer BaseRow
+        ? Cols extends []
+            ? BaseRow
+            : RenameRow<SplitSelectList<ExtractSelectList<Body>>, Cols, BaseRow>
+        : {};
+// Positionally pair each `t(a, b)` output column with the body's i-th projected
+// expression. Implemented as a single shallow mapped type (no recursive
+// intersection accumulation) to keep the CTE col-list path cheap — the recursive
+// form tipped TS's cumulative instantiation budget over on the full suite.
+export type RenameRow<BodyExprs extends string[], Cols extends string[], BaseRow> =
+    Simplify<UnionToIntersection<
+        {
+            [I in keyof Cols]: Cols[I] extends string
+                ? {
+                    [P in Cols[I]]: I extends keyof BodyExprs
+                        ? BodyExprs[I] extends string
+                            ? CteBodyColType<BodyExprs[I], BaseRow>
+                            : unknown
+                        : unknown
+                  }
+                : {}
+        }[number]
+    >>;
+export type CteBodyColKey<E extends string> =
+    ExtractAliasResult<E> extends { expr: infer Raw extends string; alias: infer A }
+        ? [A] extends [never] ? CleanIdent<Raw> : A
+        : CleanIdent<E>;
+export type CteBodyColType<E extends string, BaseRow> =
+    CteBodyColKey<E> extends infer K extends string
+        ? K extends keyof BaseRow ? BaseRow[K] : unknown
+        : unknown;

package/src/validation/dispatch.ts ADDED Viewed

@@ -0,0 +1,312 @@
+// Validation entry point, dispatch, complexity gates, query-kind helpers.
+import type { AliasesInQuery, TableKeyValid, TablesInQuery, UpdateTargetTable } from "../tables.js";
+import type { AllColumnsValidFor, AllTablesValidFor, ColumnsValidInSelectOrReturningFor, NoAliasShadowedQualifiers, OuterScopeUnqualifiedValid, QualifiedColumnRefsValidFor, UnqualifiedColumnRefsValidFor, ValidateCteShape, ValidateDerivedShape } from "./validate-columns.js";
+import type { And, StartsWith } from "../utils.js";
+import type { CteNames, NonCteTables, SingleCteMatch } from "./cte.js";
+import type { DatabaseSchema } from "../schema.js";
+import type { DerivedAliasName, DerivedFirstWord, DerivedTableMatch } from "./return-derived.js";
+import type { DistinctOnColsValid, JoinUsingColsValid, WindowFilterColsValid } from "./joins.js";
+import type { ExceedsLengthBudget, ExtractBefore, ExtractLastWhere, HasLineBreaks, TokenizeLoose, Trim, ValidationScanView } from "../parsing.js";
+import type { RefScanSegment } from "./return-types.js";
+// Core validation / inference
+// Validate against a quote-neutralised view of the query (string literal / quoted
+// alias text never carries column refs or real clauses — round-12 S1–S5, A1), but
+// ONLY for small quoted queries: the neutralisation char-walk would blow the depth
+// budget on report-scale queries, and a no-quote query has nothing to neutralise.
+// The neutralised view is computed once here (top level) so it resolves to a
+// concrete string before dispatch and never compounds with validation depth. The
+// result path is unaffected, so literal value types still infer from the original.
+export type ValidateSQLNormalized<N extends string, S extends DatabaseSchema> =
+    ShouldNeutralizeForScan<N> extends true
+        ? ValidationScanView<N> extends infer V extends string
+            ? ValidateSQLNormalizedDispatch<V, S>
+            : false
+        : ValidateSQLNormalizedDispatch<N, S>;
+export type ShouldNeutralizeForScan<N extends string> =
+    N extends `${string}'${string}`
+        ? NotReportScale<N>
+        : N extends `${string}"${string}`
+            ? NotReportScale<N>
+            : false;
+export type NotReportScale<N extends string> =
+    HasLineBreaks<N> extends true
+        ? false
+        : ExceedsLengthBudget<N> extends true
+            ? false
+            : true;
+export type ValidateSQLNormalizedDispatch<N extends string, S extends DatabaseSchema> =
+    QueryKind<N> extends "select"
+        ? IsHighComplexitySelect<N> extends true
+            ? ValidateSQLNormalizedLightSelect<N, S>
+        // A single-CTE SELECT and a leading derived-table SELECT expose only their
+        // projected output row to the outer query — validate that surface rather
+        // than the body's base tables. A derived source followed by a JOIN is left
+        // to the core path (it has additional relations in scope).
+        : [SingleCteMatch<N>] extends [never]
+            ? [DerivedTableMatch<N>] extends [never]
+                ? ValidateSQLNormalizedCore<N, S>
+                : N extends `${string} join ${string}`
+                    ? ValidateSQLNormalizedCore<N, S>
+                    : ValidateDerivedShape<N, S>
+            : ValidateCteShape<N, S>
+        : QueryKind<N> extends "update"
+        ? IsHighComplexityUpdate<N> extends true
+            ? ValidateHighComplexityUpdate<N, S>
+            : ValidateSQLNormalizedCore<N, S>
+        : ValidateSQLNormalizedCore<N, S>;
+// High-complexity UPDATE (giant CASE/EXISTS/subquery SET) validator. The full
+// core validator can't reliably parse the SET expression (its ` where ` / `=`
+// /`,` tokens live inside subqueries) and blows TS2589, which is why these were
+// blanket-accepted. Instead validate the cheap, reliable signal: the update
+// target table exists, and the columns in the REAL top-level WHERE (depth-0,
+// skipping subquery WHEREs) resolve against the query's tables/aliases. Catches
+// an invalid WHERE column (adversarial N7) while accepting the valid
+// correlated-update queries whose top-level WHERE references real columns.
+export type ValidateHighComplexityUpdate<N extends string, S extends DatabaseSchema> =
+    // Updates large enough to exceed the 700-char normalization cap still carry
+    // raw line breaks; even tokenizing them blows TS2589, so preserve the old
+    // blanket-accept for those (we cannot safely parse them). Only small, fully
+    // normalized updates (like the adversarial N7) are actually validated.
+    HasLineBreaks<N> extends true
+        ? true
+        : UpdateTargetTable<N, S> extends infer TargetKey extends string
+            ? TableKeyValid<TargetKey, S> extends true
+                ? ExtractLastWhere<N> extends infer W extends string
+                    ? Trim<W> extends ""
+                        ? true
+                        // If the top-level WHERE itself contains a subquery/paren,
+                        // the extracted predicate may not be the real top-level one
+                        // (or references other tables) — skip rather than risk a
+                        // false reject. Only the simple-WHERE case is validated.
+                        : WhereHasSubquery<W> extends true
+                            ? true
+                            // Resolve the WHERE's columns against ONLY the update
+                            // target table and its alias — NOT the whole query's
+                            // tables/aliases.
+                            : WhereColsValidForUpdate<W, TargetKey, UpdateAliasEntry<N, TargetKey>, S>
+                    : true
+                : false
+            : true;
+// A top-level WHERE is treated as "has a subquery" (and skipped) ONLY when it
+// actually contains a nested SELECT / EXISTS — those reference columns of other
+// tables that the target-table-only column check would falsely reject. A bare
+// parenthesised group is NOT a subquery: `WHERE bogus_col IN (1, 2)` is a value
+// list whose top-level column (`bogus_col`) must still be validated, so we no
+// longer bail on every `(` (which silently accepted invalid top-level columns).
+export type WhereHasSubquery<W extends string> =
+    W extends `${string}select ${string}` ? true :
+    W extends `${string}exists ${string}` ? true :
+    W extends `exists ${string}` ? true :
+    false;
+// The update statement's own table alias as a `${alias}=>${tableKey}` entry, or
+// `never` when the update has no alias. Parsed only from the `update <table>
+// [alias] set` head, so it stays cheap on huge statements.
+export type UpdateAliasEntry<N extends string, TargetKey extends string> =
+    N extends `update ${infer Rest}`
+        ? Trim<ExtractBefore<Rest, " set ">> extends `${infer _Tbl} ${infer AliasPart}`
+            // `DerivedAliasName` strips a leading `as ` so the standard
+            // `UPDATE products AS p` form yields `p`, not the keyword `as`.
+            ? DerivedAliasName<Trim<AliasPart>> extends infer A extends string
+                ? A extends ""
+                    ? never
+                    : `${A}=>${TargetKey}`
+                : never
+            : never
+        : never;
+export type WhereColsValidForUpdate<
+    W extends string,
+    TargetKey extends string,
+    AliasEntry extends string,
+    S extends DatabaseSchema
+> =
+    TokenizeLoose<W> extends infer WT extends string[]
+        ? And<
+            QualifiedColumnRefsValidFor<W, S, TargetKey, AliasEntry, WT>,
+            UnqualifiedColumnRefsValidFor<W, S, TargetKey, AliasEntry, WT, never>,
+            true,
+            true,
+            true
+        >
+        : true;
+// "Light" validator for high-complexity SELECTs: validate the cheap, bounded
+// parts (every referenced table exists, and the select/returning list resolves)
+// while SKIPPING the O(tokens x tables) loose WHERE/GROUP/HAVING/ORDER scan that
+// makes the full core validator OOM on report-scale queries. This catches an
+// invalid table or an invalid select-list column (the common false-accepts)
+// without paying for whole-query token validation. The select-list check only
+// tokenizes per-expression, so it stays within the budget that blanket-`true`
+// was protecting.
+// Small, single-line high-complexity selects can afford full validation — route
+// them to the core validator so invalid columns in WHERE / ORDER BY / GROUP BY /
+// HAVING (and window/filter clauses) are actually caught. Only genuinely
+// report-scale queries — multi-line (line breaks survive normalization) or very
+// long single-line — keep the cheap tables-plus-select-list check that the
+// blanket bypass was protecting from OOM.
+export type ValidateSQLNormalizedLightSelect<N extends string, S extends DatabaseSchema> =
+    ExceedsLengthBudget<N> extends true
+        ? ReportScaleSelectTables<N, S>
+        : HasLineBreaks<N> extends true
+            ? LightSelectTablesAndList<N, S>
+            : ValidateSQLNormalizedCore<N, S>;
+export type ReportScaleSelectTables<N extends string, S extends DatabaseSchema> =
+    TablesInQuery<N, S> extends infer Tables extends string
+        ? AllTablesValidFor<ReportScaleTablesToValidate<N, S, Tables>, S>
+        : false;
+export type ReportScaleTablesToValidate<N extends string, S extends DatabaseSchema, Tables extends string> =
+    Tables extends `${infer Schema}.${infer Table}`
+        ? TableKeyValid<`${Schema}.${Table}`, S> extends true
+            ? `${Schema}.${Table}`
+        : Table extends ReportScaleLocalRelationNames<N> | "select"
+            ? never
+            : Table extends `${ReportScalePseudoSource}${string}`
+                ? never
+                : N extends `with ${string}`
+                    ? Table extends Lowercase<Table>
+                        ? never
+                        : `${Schema}.${Table}`
+                : `${Schema}.${Table}`
+        : Tables;
+export type ReportScaleLocalRelationNames<N extends string> =
+    CteNames<N> | ReportScaleDerivedNames<N>;
+export type ReportScaleDerivedNames<N extends string> =
+    N extends `${infer _Before} from (${infer _Body}) as ${infer After}`
+        ? DerivedFirstWord<Trim<After>>
+        : N extends `${infer _Before} from (${infer _Body}) ${infer After}`
+            ? DerivedFirstWord<Trim<After>>
+            : never;
+export type ReportScalePseudoSource =
+    | "lateral"
+    | "max"
+    | "min"
+    | "avg"
+    | "sum"
+    | "count"
+    | "extract"
+    | "json_array_elements"
+    | "jsonb_array_elements"
+    | "unnest"
+    | "generate_series";
+export type LightSelectTablesAndList<N extends string, S extends DatabaseSchema> =
+    TablesInQuery<N, S> extends infer Tables extends string
+        ? AliasesInQuery<N, S> extends infer Aliases extends string
+            ? AllTablesValidFor<NonCteTables<N, S, Tables>, S> extends true
+                ? ColumnsValidInSelectOrReturningFor<N, S, Tables, Aliases> extends true
+                    ? DistinctOnColsValid<N, S, Tables, Aliases> extends true
+                        ? true
+                        : false
+                    : false
+                : false
+            : false
+        : false;
+export type ValidateSQLNormalizedCore<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[]
+                ? AllTablesValidFor<NonCteTables<N, S, Tables>, S> extends true
+                    ? AllColumnsValidFor<N, S, Tables, Aliases, LooseTokens> extends true
+                        ? NoAliasShadowedQualifiers<N, S, Tables, Aliases> extends true
+                          ? OuterScopeUnqualifiedValid<N, S> extends true
+                            ? WindowFilterColsValid<N, S, Tables, Aliases> extends true
+                                ? JoinUsingColsValid<N, S, Tables> extends true
+                                    ? DistinctOnColsValid<N, S, Tables, Aliases> extends true
+                                        ? true
+                                        : false
+                                    : false
+                                : false
+                            : false
+                          : false
+                        : false
+                    : false
+                : false
+            : false
+        : false;
+export type IsHighComplexityUpdate<N extends string> =
+    QueryKind<N> extends "update"
+        ? N extends `${string} case ${string} select ${string}`
+            ? true
+            : N extends `${string} case ${string} exists (${string}`
+                ? true
+                : false
+        : false;
+export type IsHighComplexitySelect<N extends string> =
+    QueryKind<N> extends "select"
+        ? ExceedsLengthBudget<N> extends true
+            ? true
+        : N extends `${string} offset ${string}`
+            ? true
+            : N extends `${string} snapshot_date ${string}`
+                ? true
+            : N extends `${string} join ${string} join ${string} join ${string} join ${string}`
+                ? N extends `${string} order by ${string}`
+                    ? true
+                    : N extends `${string} group by ${string}`
+                        ? true
+                        : N extends `${string} limit ${string}`
+                            ? true
+                            : false
+                : false
+        : false;
+// Query kind helpers
+export type QueryKind<N extends string> =
+    StartsWith<N, "select "> extends true ? "select" :
+    StartsWith<N, "with "> extends true ? "select" :
+    StartsWith<N, "insert "> extends true ? "insert" :
+    StartsWith<N, "update "> extends true ? "update" :
+    StartsWith<N, "delete "> extends true ? "delete" :
+    "unknown";
+// RETURNING only belongs to INSERT/UPDATE/DELETE — a SELECT (or `WITH ... SELECT`
+// without a data-modifying statement) never has a RETURNING clause, so `returning`
+// appearing in a SELECT is data (a string literal / quoted alias), not structure.
+// For data-modifying statements the match is quote-aware so ` returning ` inside
+// a string literal or quoted identifier is not mistaken for the clause.
+export type HasReturning<N extends string> =
+    QueryKind<N> extends "select"
+        ? false
+        : HasReturningQuoteAware<N>;
+export type HasReturningQuoteAware<
+    S extends string,
+    InString extends boolean = false,
+    InDString extends boolean = false,
+    Steps extends any[] = []
+> = string extends S
+    ? false
+    : Steps["length"] extends 1200
+        ? S extends `${string} returning ${string}` ? true : false
+        : InString extends true
+            ? S extends `${infer C}${infer Rest}`
+                ? HasReturningQuoteAware<Rest, C extends "'" ? false : true, InDString, [any, ...Steps]>
+                : false
+            : InDString extends true
+                ? S extends `${infer C}${infer Rest}`
+                    ? HasReturningQuoteAware<Rest, InString, C extends `"` ? false : true, [any, ...Steps]>
+                    : false
+                : S extends ` returning ${string}`
+                    ? true
+                    : S extends `${infer C}${infer Rest}`
+                        ? HasReturningQuoteAware<Rest, C extends "'" ? true : false, C extends `"` ? true : false, [any, ...Steps]>
+                        : false;